1000

A+B Problem

极高精度版本的qwq a+b

Two integer a,b (0<=a,b<=10)

Output a+b

1 2

3

0

国际惯例题,相关请看FAQ

 

2017-11-27 16:50:02

1

10

N

77

175

0

1102

【贪心】NOIP_2004.TG2:合并果子

在一个果园里,多多已经将所有的果子打了下来,而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。 每一次合并,多多可以把两堆果子合并到一起,消耗的体力等于两堆果子的重量之和。可以看出,所有的果子经过n-1次合并之后,就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。 因为还要花大力气把这些果子搬回家,所以多多在合并果子时要尽可能地节省体力。假定每个果子重量都为1,并且已知果子的种类数和每种果子的数目,你的任务是设计出合并的次序方案,使多多耗费的体力最少,并输出这个最小的体力耗费值。 例如有3种果子,数目依次为129。可以先将12堆合并,新堆数目为3,耗费体力为3。接着,将新堆与原先的第三堆合并,又得到新的堆,数目为12,耗费体力为12。所以多多总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。

输入文件中包括两行:第一行是一个整数n(1<n<=10000),表示果子的种类数。 第二行包含n个整数,用空格分隔,第i个整数ai(1<ai<=20000)是第i种果子的数目。

输出文件包括一行:这一行只包含一个整数,也就是最小的体力耗费值。(输入数据保证这个值小于2<sup>31</sup>。)

3 1 2 9

15

0

【数据规模】 对于30%的数据,保证有n<=1000: 对于50%的数据,保证有n<=5000; 对于全部的数据,保证有n<=10000

NOIP_2004.TG2:合并果子

2017-06-02 20:54:12

1

64

N

66

139

0

1101

NOIP_2004.TG1:津津的储蓄计划

津津的零花钱一直都是自己管理。每个月的月初妈妈给津津300元钱,津津会预算这个月的花销,并且总能做到实际花销和预算的相同。 为了让津津学习如何储蓄,妈妈提出,津津可以随时把整百的钱存在她那里,到了年末她会加上20%还给津津。因此津津制定了一个储蓄计划:每个月的月初,在得到妈妈给的零花钱后,如果她预计到这个月的月末手中还会有多于100元或恰好100元,她就会把整百的钱存在妈妈那里,剩余的钱留在自己手中。 例如11月初津津手中还有83元,妈妈给了津津300元。津津预计11月的花销是180元,那么她就会在妈妈那里存200元,自己留下183元。到了11月月末,津津手中会剩下3元钱。 津津发现这个储蓄计划的主要风险是,存在妈妈那里的钱在年末之前不能取出。有可能在某个月的月初,津津手中的钱加上这个月妈妈给的钱,不够这个月的原定预算。如果出现这种情况,津津将不得不在这个月省吃俭用,压缩预算。 现在请你根据20041月到12月每个月津津的预算,判断会不会出现这种情况。如果不会,计算到2004年年末,妈妈将津津平常存的钱加上20%还给津津之后,津津手中会有多少钱。

输入文件save.in包括12行数据,每行包含一个小于350的非负整数,分别表示1月到12月津津的预算。

输出文件save.out包括一行,这一行只包含一个整数。 如果储蓄计划实施过程中出现某个月钱不够用的情况,输出-XX表示出现这种情况的第一个月; 否则输出到2004年年末津津手中会有多少钱。

【样例输入1 290 230 280 200 300 170 340 50 90 80 200 60 【样例输入2 290 230 280 200 300 170 330 50 90 80 200 60

【样例输出1 -7 【样例输出2 1580

0

 

NOIP_2004.TG1:津津的储蓄计划

2017-03-21 18:01:55

1

64

N

5

15

0

1001

USACO_1.1-1:你的飞碟在这儿!

科学家们在研究彗星后惊讶地发现,在每一个慧星后面都有一个不明飞行物UFO。 这些不明飞行物时常来带走来自地球上的一些支持者。不幸地,他们的空间在每次旅行只能带上一群支持者。 他们要做的是用一种聪明的方案让某个支持彗星UFO的团体都被慧星带走。他们为每个慧星起了一个名字,通过这些名字来决定一个团体是不是特定的慧星带走。 那个相配方案的细节是这样的: 所有团体的名字和慧星的名字都以下列各项方式转换成一个数字: 这个最后的数字代表名字中所有字母的信息,"A"  1  "Z"  26。 举例来说,团体 "USACO" 会是 21*19*1*3*15=17955 。 如果团体的数字 mod 47 等于慧星的数字 mod 47,那么你要告诉这个团体:准备好行李,走吧 ! 现在,你要写一个程序来通过团体的名字和彗星的名字来决定一个组是否应该与在那一颗慧星后面的不明飞行物搭配。 写一个程序读入慧星的名字和团体的名字,如果搭配打印"GO"否者打印"STAY" 团体的名字和慧星的名字将会是没有空格或标点的一串大写字母(不超过6个字母)。

 1 : 彗星的名字(一个长度为16的字符串) 第 2 : 团体的名字(一个长度为16的字符串)

只有一行----"STAY""GO".

ABSTAR USACO

STAY

0

http://ace.delos.com/usacoprob2?a=XogK3Q5R3CD&S=ride

USACO 1.1-1

2017-03-18 10:42:56

1

64

N

29

57

0

1002

USACO_1.1-2:贪婪的礼物送礼者

对于一群要互送礼物的朋友,你要确定每个人送出的礼物比收到的多多少(and vice versa for those who view gift giving with cynicism)。 在这一个问题中,每个人都准备了一些钱来送礼物,而这些钱将会被平均分给那些将收到他的礼物的人。 然而,在任何一群朋友中,有些人将送出较多的礼物(可能是因为有较多的朋友),有些人有准备了较多的钱。 给出一群朋友, 没有人的名字会长于 14 字符,给出每个人将花在送礼上的钱,和将收到他的礼物的人的列表,请确定每个人收到的比送出的钱多的数目。

 1 : 人数NP,2<= NP<=10  2 NP+1 :NP个在组里人的名字 一个名字一行 第NP2到最后: 这里的NP段内容是这样组织的: 第一行是将会送出礼物人的名字。 第二行包含二个数字: 第一个是原有的钱的数目(在02000的范围里),第二个NGi是将收到这个送礼者礼物的人的个数 如果 NGi 是非零的, 在下面 NGi 行列出礼物的接受者的名字,一个名字一行。

输出 NP 行 每行是一个的名字加上空格再加上收到的比送出的钱多的数目。 对于每一个人,他名字的打印顺序应和他在输入的2NP1行中输入的顺序相同。所有的送礼的钱都是整数。 每个人把相同数目的钱给每位要送礼的朋友,而且尽可能多给,不能给出的钱被送礼者自己保留。

5 dave laura owen vick amr dave 200 3 laura owen vick owen 500 1 dave amr 150 2 vick owen laura 0 2 amr vick vick 0 0

dave 302 laura 66 owen -359 vick 141 amr -150

0

测试系统是 Linux 符合标准的 Unix 的协定。 用'\n'作为行的结束。这和 Windows 系统用'\n'  '\r'作为行的结束是不同的。 你的程序不要被这困住了。

USACO 1.1-2

2017-03-18 10:45:52

1

64

N

8

10

0

1003

USACO_1.1-3:黑色星期五

13号又是星期五是一个不寻常的日子吗?13号在星期五比在其他日少吗?为了回答这个问题,写一个程序来计算在n年里13日落在星期一,星期二......星期日的次数.这个测试从190011日到1900+n-11231.n是一个非负数且不大于400. 这里有一些你要知道的: 190011日是星期一.4,6,119月有30.其他月份除了2月都有31.闰年2月有29,平年2月有28.年份可以被4整除的为闰年(1992=4*498 所以 1992年是闰年,但是1990年不是闰年)以上规则不适合于世纪年.可以被400整除的世纪年为闰年,否则为平年.所以,1700,1800,19002100年是平年,2000年是闰年.请不要预先算好数据!

一个整数n.

七个在一行且相分开的整数,它们代表13日是星期六,星期日,星期一.....星期五的次数.

20

36 33 34 33 35 35 34

0

 

USACO 1.1-3

2017-03-18 10:49:35

1

64

N

9

10

0

1004

USACO_1.1-4:破碎的项链

你有一条由N个红色的,白色的,或蓝色的珠子组成的项链(3<=N<=350),珠子是随意安排的。 这里是 n=29 的二个例子: <img src="/JudgeOnline/upload/image/20170720/20170720151431_18434.png" alt="" /> 第一和第二个珠子在图片中已经被作记号。 图片 A 中的项链可以用下面的字符串表示: brbrrrbbbrrrrrbrrbbrbbbbrrrrb . 假如你要在一些点打破项链,展开成一条直线,然后从一端开始收集同颜色的珠子直到你遇到一个不同的颜色珠子,在另一端做同样的事。(颜色可能与在这之前收集的不同) 确定应该在哪里打破项链来收集到最大多数的数目的子。 Example 举例来说,在图片 A 中的项链,可以收集到8个珠子,在珠子 9 和珠子 10 或珠子 24 和珠子 25 之间打断项链。 在一些项链中,包括白色的珠子如图片 B 所示。 当收集珠子的时候,一个被遇到的白色珠子可以被当做红色也可以被当做蓝色。 表现项链的字符串将会包括三符号 r  b  w 。 写一个程序来确定从一条被供应的项链最大可以被收集珠子数目。

 1 : N, 珠子的数目 第 2 : 一串度为N的字符串, 每个字符是 r  b  w

单独的一行包含从被供应的项链可以被收集的珠子数目的最大值。

29 wwwbbrwrbrbrrbrbrwrwwrbwrwrrb

11

0

 

USACO_1.1-4

2017-07-20 15:14:42

1

64

N

5

13

0

1005

USACO_1.2-1:挤牛奶

三个农民每天清晨5点起床,然后去牛棚给3头牛挤奶。第一个农民在300时刻(5点开始计时,秒为单位)给他的牛挤奶,一直到1000时刻。第二个农民在700时刻开始,在 1200时刻结束。第三个农民在1500时刻开始2100时刻结束。期间最长的至少有一个农民在挤奶的连续时间为900(300时刻到1200时刻),而最长的无人挤奶的连续时间(从挤奶开始一直到挤奶结束)300(1200时刻到1500时刻)。 你的任务是编一个程序,读入一个有N个农民(1 <= N <= 5000)N头牛的工作时间列表,计算以下两点(均以秒为单位): 最长至少有一人在挤奶的时间段。 最长的无人挤奶的时间段。

Line 1: 一个整数N Lines 2..N+1: 每行两个小于1000000的非负整数,表示一个农民的开始时刻与结束时刻。

一行,两个整数,即题目所要求的两个答案。

3 300 1000 700 1200 1500 2100

900 300

0

 

USACO_1.2-1:

2017-03-18 11:03:39

1

64

N

8

10

0

1006

USACO_1.2-2:方块转换

一块N x N1<=N<=10)正方形的黑白瓦片的图案要被转换成新的正方形图案。写一个程序来找出将原始图案按照以下列转换方法转换成新图案的最小方式: 1:转90度:图案按顺时针转90度。 2:转180度:图案按顺时针转180度。 3:转270度:图案按顺时针转270度。 4:反射:图案在水平方向翻转(形成原图案的镜像)。 5:组合:图案在水平方向翻转,然后按照1-3之一转换。 6:不改变:原图案不改变。 7:无效转换:无法用以上方法得到新图案。 如果有多种可用的转换方法,请选择序号最小的那个。

第一行: 单独的一个整数N。 第二行到第N+1行: N行每行N个字符(不是“@”就是“-”);这是转换前的正方形。 第N+2行到第2*N+1行: N行每行N个字符(不是“@”就是“-”);这是转换后的正方形。

单独的一行包括17之间的一个数字(在上文已描述)表明需要将转换前的正方形变为转换后的正方形的转换方法。

3 @-@ --- @@- @-@ @-- --@

1

0

 

USACO_1.2-2

2017-03-18 11:04:00

1

64

N

4

9

0

1007

USACO_1.2-4:回文平方数

回文数是指从左向右念和从右像做念都一样的数。如12321就是一个典型的回文数。 给定一个进制B(2<=B<=20十进制),输出所有的大于等于1小于等于300且它的平方用B进制表示时是回文数的数。用’A’,’B’……表示1011等等。

共一行,一个单独的整数B(B用十进制表示)

每行两个数字,第二个数是第一个数的平方,且第二个数是回文数。(注意:这两个数都应该在B那个进制下)

10

1 1 2 4 3 9 11 121 22 484 26 676 101 10201 111 12321 121 14641 202 40804 212 44944 264 69696

0

 

USACO_1.2-4

2017-03-18 11:04:00

1

64

N

5

7

0

1008

USACO_1.2-5:双重回文数

如果一个数从左往右读和从右往左读都是一样,那么这个数就叫做回文数。例如,12321就是一个回文数,而77778就不是。当然,回文数的首和尾都应是非零的,因此0220就不是回文数。 事实上,有一些数(如21),在十进制时不是回文数,但在其它进制(如二进制时为10101)时就是回文数。 编一个程序,从文件读入两个十进制数N (1 <= N <= 15)S (0 < S < 10000)然后找出前N个满足大于S且在两种或两种以上进制(二进制至十进制)上是回文数的十进制数,输出到文件上。 本问题的解决方案不需要使用大于4字节的整型变量。

只有一行,用空格隔开的两个数NS

N, 每行一个满足上述要求的数,并按从小到大的顺序输出。

3 25

26 27 28

0

 

USACO_1.2-5

2017-03-18 11:04:00

1

64

N

2

3

0

1009

USACO_1.3-1:混合牛奶

牛奶包装是一个如此低利润的生意,所以尽可能低的控制初级产品(牛奶)的价格变的十分重要。请帮助快乐的牛奶制造公司(Merry Milk Makers')以可能的最廉价的方式取得他们所需的牛奶。快乐的牛奶制造公司从一些农民那购买牛奶,每个农民卖给牛奶制造公司的价格不一定相同。而且,如一只母牛一天只能生产一定量的牛奶,农民每一天只有一定量的牛奶可以卖。每天,快乐的牛奶制造公司从每个农民那购买一定量的牛奶,少于或等于农民所能提供的最大值。给出快乐牛奶制造公司的每日的牛奶需求,连同每个农民的可提供的牛奶量和每加仑的价格,请计算快乐的牛奶制造公司所要付出钱的最小值。 注意:每天农民生产的牛奶的总数对快乐的牛奶制造公司来说足够的。

 1 :二个整数, N  M。 第一个数值,N,(0<= N<=2,000,000)是快乐的牛奶制造者的一天需要牛奶的数量。 第二个数值,M,(0<= M<=5,000)是提供牛奶的农民个数。 第 2  M+1 :每行二个整数,Pi  Ai Pi(0<= Pi<=1,000) 是农民 i 牛奶的价格。 Ai(0 <= Ai <= 2,000,000)是农民 i 一天能卖给快乐的牛奶制造者的牛奶数量。

单独的一行包含单独的一个整数,表示快乐的牛奶制造者拿到所需的牛奶所要的最小费用。

100 5 5 20 9 40 3 10 8 80 6 30

630

0

 

USACO_1.3-1

2017-03-18 11:04:00

1

64

N

3

5

0

1010

USACO_1.3-2:修理牛棚

在一个暴风雨的夜晚,农民约翰的牛棚的屋顶、门被吹飞了。 好在许多牛正在度假,所以牛棚没有住满。 剩下的牛一个紧挨着另一个被排成一行来过夜。 有些牛棚里有牛,有些没有。 所有的牛棚有相同的宽度。 自门遗失以后,农民约翰很快在牛棚之前竖立起新的木板。 他的新木材供应者将会供应他任何他想要的长度,但是供应者只能提供有限数目的木板。 农民约翰想将他购买的木板总长度减到最少。 给出 M(1<= M<=50),可能买到的木板最大的数目;S(1<= S<=200),牛棚的总数;C(1 <= C <=S) 牛棚里牛的数目,和牛所在的牛棚的编号stall_number(1 <= stall_number <= S),计算拦住所有有牛的牛棚所需木板的最小总长度。 输出所需木板的最小总长度作为的答案。

 1 : M  S  C(用空格分开)  2  C+1: 每行包含一个整数,表示牛所占的牛棚的编号。

单独的一行包含一个整数表示所需木板的最小总长度。

4 50 18 3 4 6 8 14 15 16 17 21 25 26 27 30 31 40 41 42 43

25

0

[ 一种最优的安排是用板拦住牛棚3-8,14-21,25-31,40-43.]

USACO_1.3-2

2017-03-18 11:04:01

1

64

N

3

4

0

1011

USACO_1.3-3:calfflac

据说如果你给无限只母牛和无限台巨型便携式电脑(有非常大的键盘),那么母牛们会制造出世上最棒的回文。你的工作就是去寻找这些牛制造的奇观(最棒的回文)。 在寻找回文时不用理睬那些标点符号、空格(但应该保留下来以便做为答案输出),只用考虑字母'A'-'Z''a'-'z'。要你寻找的最长的回文的文章是一个不超过20,000个字符的字符串。 我们将保证最长的回文不会超过2,000个字符(在除去标点符号、空格之前)

输入文件不会超过20,000字符。这个文件可能一行或多行,但是每行都不超过80个字符(不包括最后的换行符)

输出的第一行应该包括找到的最长的回文的长度。 下一行或几行应该包括这个回文的原文(没有除去标点符号、空格),把这个回文输出到一行或多行(如果回文中包括换行符)。 如果有多个回文长度都等于最大值,输出最前面出现的那一个。

Confucius say:Madam,I'm Adam.

11 Madam,I'm Adam

0

 

USACO_1.3-3

2017-03-18 11:12:04

1

64

N

2

3

0

1012

USACO_1.3-4:牛式

<p> 下面是一个乘法竖式,如果用我们给定的那n个数字来取代*。 并且可以使式子成立的话,我们就叫这个式子牛式。 <img src="/JudgeOnline/upload/image/20170720/20170720152039_78748.jpg" alt="" /> </p> <p> 数字只能取代*号出现位置,当然第一位不能为0。 写一个程序找出所有的牛式。所选用数字均来自于集合{1,2,3,4,5,6,7,8,9} </p>

Line 1:你将可能使用的数字的个数n Line 2:N个用空格分开,在你的程序中允许使用的数字(每个数字都∈{1,2,3,4,5,6,7,8,9})。

共一行,一个数字。表示牛式的总数。

5 2 3 4 6 8

1 符合条件的牛式如下: 2 2 2 x 2 2 ------ 4 4 4 4 4 4 --------- 4 8 8 4

0

 

USACO_1.3-4

2017-07-20 15:20:47

1

64

N

0

3

0

1013

USACO_1.4-1:铺放矩形块(IOI 95)

<p> 给定4个矩形块,找出一个最小的封闭矩形将这4个矩形块放入,但不得相互重叠。所谓最小矩形指该矩形面积最小。 <img src="/JudgeOnline/upload/image/20170720/20170720151830_62930.jpg" alt="" /> </p> <p> 所有4个矩形块的边都与封闭矩形的边相平行,图1示出了铺放4个矩形块的6种方案。这6种方案是仅可能的基本铺放方案。因为其它方案能由基本方案通过旋转和镜像反射得到。 可能存在满足条件且有着同样面积的各种不同的封闭矩形,你应该输出所有这些封闭矩形的边长。 </p>

共有4行。每一行用两个正整数来表示一个给定的矩形块的两个边长。矩形块的每条边的边长范围最小是1,最大是50

总行数为解的总数加1。第一行是一个整数,代表封闭矩形的最小面积(子任务A)。接下来的每一行都表示一个解,由数P和数Q来表示,并且P≤Q(子任务B)。这些行必须根据P的大小按升序排列,P小的行在前,大的在后。且所有行都应是不同的。

1 2 2 3 3 4 4 5

40 4 10 5 8

0

 

USACO_1.4-1

2017-07-20 15:18:44

1

64

N

2

3

0

1014

USACO_1.4-2:The Clocks 时钟IOI'94-Day 2

<p> 考虑将如此安排在一个 3 x3 行列中的九个时钟: <img src="/JudgeOnline/upload/image/20170720/20170720152224_63716.gif" alt="" />  </p> <p> 目标要找一个最小的移动顺序次将所有的指针指向12点。下面原表格列出了9种不同的旋转指针的方法,每一种方法都叫一次移动。选择19号移动方法,将会使在表格中对应的时钟的指针顺时针旋转90度。 移动方法 受影响的时钟 <img src="/JudgeOnline/upload/image/20170720/20170720152442_26882.png" alt="" /> </p> <p>  Example <img src="/JudgeOnline/upload/image/20170720/20170720152847_74763.png" alt="" /> [但这可能不是正确的方法,请看下面] </p>

1-3: 三个空格分开的数字,每个数字表示一个时钟的初始时间,3,6,9,12。数字的含意和上面第一个例子一样。

单独的一行包括一个用空格分开的将所有指针指向12:00的最短移动顺序的列表。 如果有多种方案,输出那种使的连接起来数字最小的方案。(举例来说5 2 4 6 < 9 3 1 1)

9 9 12 6 6 6 6 3 6

4 5 8 9

0

本题测试数据USACO共给出了9组,不过只通过了5组,因而只放了5组测试数据,还有4组数据为Wrong Answer,具体原因现在不明! (注明:我的程序是在USACO上没有问题的,数据全部通过!)

USACO_1.4-2

2017-07-20 15:28:56

50

640

N

2

3

0

1015

USACO_1.4-3:ArithmeticProgressions等差数列

一个等差数列是一个能表示成a, a+b, a+2b,..., a+nb (n=0,1,2,3,...)的数列。 在这个问题中a是一个非负的整数,b是正整数。写一个程序来找出在双平方数集合S中长度为n的等差数列。双平方数集合是所有能表示成p^2q^2的数的集合。

第一行: N(3<= N<=25),要找的等差数列的长度。 第二行: M(1<= M<=250),搜索双平方数的上界0 <= p,q <= M

如果没有找到数列,输出`NONE'。 如果找到了,输出一行或多行, 每行由于二个整数组成:a,b。 这些行应该先按b排序再按a排序。 所求的等差数列将不会多于10,000个。

5 7

1 4 37 4 2 8 29 8 1 12 5 12 13 12 17 12 5 20 2 24

0

TIME LIMIT: 5

USACO_1.4-3

2017-03-18 11:12:04

15

640

N

2

3

0

1016

USACO_1.4-4:Mother's Milk 母亲的牛奶

农民约翰有三个容量分别是A,B,C升的桶,A,B,C分别是三个从120的整数. 最初,AB桶都是空的,而C桶是装满牛奶的。有时,约翰把牛奶从一个桶倒到另一个桶中,直到被灌桶装满或原桶空了。当然每一次灌注都是完全的。由于节约,牛奶不会有丢失。 写一个程序去帮助约翰找出当A桶是空的时候,C桶中牛奶所剩量的所有可能性。

单独的一行包括三个整数A,BC

只有一行,升序地列出当A桶是空的时候,C桶牛奶所剩量的所有可能性。

8 9 10

1 2 8 9 10

0

 

USACO_1.4-4

2017-03-18 11:12:04

1

64

N

0

3

0

1017

USACO_1.5-1:Number Triangles 数字金字塔

考虑在下面被显示的数字金字塔。 写一个程序来计算从最高点开始在底部任意处结束的路径经过数字的和的最大。每一步可以走到左下方的点也可以到达右下方的点。 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 在上面的样例中,7  3  8  7  5 的路径产生了最大和:30

第一个行包含 R(1<= R<=1000) ,表示行的数目。 后面每行为这个数字金字塔特定行包含的整数。 所有的被供应的整数是非负的且不大于100

单独的一行包含那个可能得到的最大的和。

5 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5

30

0

很奇怪的问题再次出现,本题共9组数据,我的程序放上去的8组数据都没有问题,只有最后一组数据报出Wrong Answer 最后一组数据规模较大,为上限:1000 但我的程序应问题不大,毕竟是在USACO上通过的!

USACO_1.5-1

2017-03-18 11:12:04

5

64

N

2

5

0

1018

USACO_1.5-2:Prime Palindromes 回文质数

因为151既是一个质数又是一个回文数(从左到右和从右到左是看一样的),所以 151 号是回文质数。 写一个程序来找出范围[a,b](5 <= a < b <= 100,000,000)间的所有回文质数;

 1 : 二个整数 a  b .

输出一个回文质数的列表,一行一个。

5 500

5 7 11 101 131 151 181 191 313 353 373 383

0

 

USACO_1.5-2

2017-03-18 11:12:04

1

64

N

3

6

0

1019

USACO_1.5-3:Superprime Rib 特殊的质数肋骨

农民约翰的母牛总是生产出最好的肋骨。你能通过农民约翰和美国农业部标记在每根肋骨上的数字认出它们。 农民约翰确定他卖给买方的是真正的质数肋骨,是因为从右边开始切下肋骨,每次还剩下的肋骨上的数字都组成一个质数,举例来说: 7 3 3 1 全部肋骨上的数字 7331是质数;三根肋骨 733是质数;二根肋骨 73 是质数;当然,最后一根肋骨 7 也是质数。 7331 被叫做长度 4 的特殊质数。 写一个程序对给定的肋骨的数目 N (1<=N<=8),求出所有的特殊质数。数字1不被看作一个质数。

单独的一行包含N

按顺序输出长度为 N 的特殊质数,每行一个。

4

2333 2339 2393 2399 2939 3119 3137 3733 3739 3793 3797 5939 7193 7331 7333 7393

0

 

USACO_1.5-3

2017-03-18 11:12:04

1

64

N

10

11

0

1020

(图挂了)USACO_1.5-4:Checker Challenge 跳棋的挑战

检查一个如下的6 x 6的跳棋棋盘,有六个棋子被放置在棋盘上,使得每行,每列,每条对角线(包括两条主对角线的所有对角线)上都至多有一个棋子。 列号 <img border="0" src="http://60.191.162.158:8080/JudgeOnline/images/p1020.jpg" /> 上面的布局可以用序列2 4 6 1 3 5来描述,第i个数字表示在第i行的相应位置有一个棋子,如下: 行号 1 2 3 4 5 6 列号 2 4 6 1 3 5 这只是跳棋放置的一个解。请编一个程序找出所有跳棋放置的解。并把它们以上面的序列方法输出。解按字典顺序排列。请输出前3个解。最后一行是解的总个数。 特别注意: 对于更大的N(棋盘大小N x N)你的程序应当改进得更有效。不要事先计算出所有解然后只输出,这是作弊。如果你坚持作弊,那么你登陆USACO Training的帐号将被无警告删除

一个数字N (6 <= N <= 13) 表示棋盘是N x N大小的。

前三行为前三个解,每个解的两个数字之间用一个空格隔开。第四行只有一个数字,表示解的总数。

6

2 4 6 1 3 5 3 6 2 5 1 4 4 1 5 2 6 3 4

0

 

USACO_1.5-4

2017-07-20 15:39:46

1

64

N

0

3

0

1021

USACO教程:Complete Search枚举搜索

思想: 写枚举搜索时应遵循KISS原则(Keep it simple stupid,译为写最单纯愚蠢的程序,意思是应把程序写得尽量简洁),竞赛时写程序的最终目标就是在限制时间内求出解,而不需太在意否还有更快的算法。 枚举搜索具有强大的力量,他用直接面向答案并尝试所有方案的方法发现答案。这种算法几乎总是解题时你第一个想到的方法。如果它能在规定的时间与空间限制内找出解,那么它常常很容易编写与调试。这就意味着你可以有时间去解答其他难题,即那些不能显示枚举算法强大的题目。 如果你面对一道可能状态小于两百万的题目,那么你可以考虑使用枚举搜索。尝试所有的状态,看看它们是否可行。 小心!小心! 有时,题目不会直接要求你使用枚举算法。 例题1:派对灯 [IOI 98] 在一次IOI派对上有N个灯和4个灯开光,第一个开关可以使所有灯改变状态(关上开着的灯,开启关着的灯),第二个开关可以改变所有偶数位上灯的状态,第三个开关可以改变所有奇数位上灯的状态,第四个开关控制着灯14710……3n+1)。 告诉你N的值和所有按开关的次数(小于10,000次)。并告诉你某些灯的状态(例如:7号灯是关着的,10号灯是开着的)请编程输出所有灯可能的最后状态。 很明显,每次按开关你都要偿试4种可能。那么总共要试 410000 次(大约 106020),那意味着你没有足够的时间去使用枚举搜索,但是我们将枚举方法改进一下,那就可以使用枚举了。因为无论有多少个灯,由于开关控制的特殊性,都会出现6个灯一次循环的情况,即1号灯的状态永远与7号灯,13号灯,19号灯……相同,2号灯的状态也永远与8号灯,14号灯,20号灯……相同。同样,无论你按了多少次开关,按同一个开关两次就相当于没有按该开关,那么每一个开关就只需要考虑按一次或没有按,那么这题的枚举量就很小了。 例题2: 时钟调整 [IOI 94] 有九个钟被摆放在一个3 X 3的矩阵中,它们各自指向1200900600300中的一种,你的目的是将它们的指针全部调向1200。很遗憾,每一次调整你都只能从九种调整方案中选择一种执行(九种方案已被从19编号),每一种方案可以改变固定钟的状态(例如:方案1控制钟123,方案2控制钟147,方案3控制钟5689……),即将方案指定的所有钟向前拨快3小时(使时针向顺时针方向旋转90度),请你输出一个数列,使得按该数列表示方案执行后,所有钟都指向1200。并且如果把整个序列看作一个数,要求该数最小。 最容易想到的方法是用递归枚举19的方案在该步使用。很可怕,由于递归的层数在此没有限定,所以将用掉 9k 的时间(k为层数),那可能是相当巨大的。其实,不用紧张,细心的你一定会发现:当一个方案执行4次后,就相当于没有执行,又因为题目要求输出最优解,那么任意一个方案都没有必要4次以上执行。也就是说,只需要枚举每一个方案的4种情况(没执行,执行123次)就可以了。他仅有49 ,约262,072此枚举,我们的计算机1s内就可以算完,应该算是极快了。 类似问题: 挤牛奶 [USACO 1996 初赛] 给出一个挤牛奶的顺序(农夫 A  300 秒到 1000秒时挤牛奶, 农夫 B 700 秒到 1200秒),要求输出: 最长的有人挤牛奶的时间。 最长的没人挤牛奶的时间。 完全数牛与完全数牛群 [USACO 1995 决赛] 如果一个数可以由它的某几个约数相加得到,那么我们叫它完全数,如28 = 1 + 2 + 4 + 7 + 14。而一对完全对数就是指两个数都可以由对方的约数相加得出。同样一个完全数组就是一个数组的第一个数可以由第二个数的约数加和得到,第二个数也可以由第三个数的约数相加得到……最后一个数可以由第一个数的约数加和得到。 现在Farmer John已经将它的牛儿们编好了号(132000)请找出其中所有的完全数牛与完全数牛群。

Complete Search The Idea Solving a problem using complete search is based on the ``Keep It Simple, Stupid'' principle. The goal of solving contest problems is to write programs that work in the time allowed, whether or not there is a faster algorithm. Complete search exploits the brute force, straight-forward, try-them-all method of finding the answer. This method should almost always be the first algorithm/solution you consider. If this works within time and space constraints, then do it: it's easy to code and usually easy to debug. This means you'll have more time to work on all the hard problems, where brute force doesn't work quickly enough. In the case of a problem with only fewer than a couple million possibilities, iterate through each one of them, and see if the answer works. Careful, Careful Sometimes, it's not obvious that you use this methodology. Problem: Party Lamps [IOI 98] You are given N lamps and four switches. The first switch toggles all lamps, the second the even lamps, the third the odd lamps, and last switch toggles lamps 1, 4, 7, 10, ... . Given the number of lamps, N, the number of button presses made (up to 10,000), and the state of some of the lamps (e.g., lamp 7 is off), output all the possible states the lamps could be in. Naively, for each button press, you have to try 4 possibilities, for a total of 410000 (about 106020 ), which means there's no way you could do complete search (this particular algorithm would exploit recursion). Noticing that the order of the button presses does not matter gets this number down to about 100004 (about 1016 ), still too big to completely search (but certainly closer by a factor of over 106000 ). However, pressing a button twice is the same as pressing the button no times, so all you really have to check is pressing each button either 0 or 1 times. That's only 24 = 16 possibilities, surely a number of iterations solvable within the time limit. Problem 3: The Clocks [IOI 94] A group of nine clocks inhabits a 3 x 3 grid; each is set to 12:00, 3:00, 6:00, or 9:00. Your goal is to manipulate them all to read 12:00. Unfortunately, the only way you can manipulate the clocks is by one of nine different types of move, each one of which rotates a certain subset of the clocks 90 degrees clockwise. Find the shortest sequence of moves which returns all the clocks to 12:00. The ``obvious'' thing to do is a recursive solution, which checks to see if there is a solution of 1 move, 2 moves, etc. until it finds a solution. This would take 9k time, where k is the number of moves. Since k might be fairly large, this is not going to run with reasonable time constraints. Note that the order of the moves does not matter. This reduces the time down to k9 , which isn't enough of an improvement. However, since doing each move 4 times is the same as doing it no times, you know that no move will be done more than 3 times. Thus, there are only 49 possibilities, which is only 262,072, which, given the rule of thumb for run-time of more than 10,000,000 operations in a second, should work in time. The brute-force solution, given this insight, is perfectly adequate. Sample Problems Milking Cows [USACO 1996 Competition Round] Given a cow milking schedule (Farmer A milks from time 300 to time 1000, Farmer B from 700 to 1200, etc.), calculate The longest time interval in which at least one cow was being milked The longest time interval in which no cow is being milked Perfect Cows & Perfect Cow Cousins [USACO 1995 Final Round] A perfect number is one in which the sum of the proper divisors add up to the number. For example, 28 = 1 + 2 + 4 + 7 + 14. A perfect pair is a pair of numbers such that the sum of the proper divisor of each one adds up to the other. There are, of course, longer perfect sets, such that the sum of the divisors of the first add up to the second, the second's divisors to the third, etc., until the sum of the last's proper divisors add up to the first number. Each cow in Farmer John's ranch is assigned a serial number. from 1 to 32000. A perfect cow is one which has a perfect number as its serial. A group of cows is a set of perfect cow cousins if their serial numbers form a perfect set. Find all perfect cows and perfect cow cousins.

 

 

 

0

 

 

2017-03-18 11:19:08

1

64

N

3

3

0

1022

USACO教程:Greedy Algorithm贪心算法

样例:牛棚修理 [1999 USACO 春季公开赛] Farmer John 有一列牛棚,在一次暴风中,牛棚的一整面墙都被吹倒了,但还好不是每一间牛棚都有牛。Farmer John 决定卖木料来修理牛棚,然而,刻薄的木材提供商却只能提供有限块的木料(木料的长度不限),现在告诉你关着牛的牛棚号,和提供的木材个数N,你的任务是编程求出最小的木块长度和。(1 <= N <= 50) 贪心思想: 贪心思想的本质是每次都形成局部最优解,换一种方法说,就是每次都处理出一个最好的方案。例如:在样例中,若已经发现 N = 5 时的最优解,那么我们可以直接利用 N = 5 的最优解构成 N = 4 的最优解,而不用去考虑那些 N = 4 时的其他非最优解。 贪心算法的最大特点就是快。通常,二次方级的存储要浪费额外的空间,而且很不幸,那些空间经常得不出正解。但是,当使用贪心算法时,这些空间可以帮助算法更容易实现且更快执行。 贪心的难点: 贪心算法有两大难点: 如何贪心: 怎样才能从众多可行解中找到最优解呢?其实,大部分都是有规律的。在样例中,贪心就有很明显的规律。但你得到了 N = 5 时的最优解后,你只需要在已用上的5块木板中寻找最靠近的两块,然后贴上中间的几个牛棚,使两块木板变成一块。这样生成的 N = 4 的解必定最优。因为这样木板的浪费最少。同样,其他的贪心题也会有这样的性质。正因为贪心有如此性质,它才能比其他算法要快。 贪心的正确性: 要证明贪心性质的正确性,才是贪心算法的真正挑战,因为并不是每次局部最优解都会与整体最优解之间有联系,往往靠贪心生成的解不是最优解。这样,贪心性质的证明就成了贪心算法正确的关键。一个你想出的贪心性质也许是错的,即使它在大部分数据中都是可行的,你必须考虑到所有可能出现的特殊情况,并证明你的贪心性质在这些特殊情况中仍然正确。这样经过千锤百炼的性质才能构成一个正确的贪心。 在样例中,我们的贪心性质是正确的。如下: 假设我们的答案盖住了较大的空牛棚连续列,而不是较小的。那么我们把那部分盖空牛棚的木板锯下来,用来把较小的空牛棚连续列盖住,还会有剩余。那么锯掉它们!还给木材商!同时我们的解也变小了。也就是说,我们获得更优的解。所以,靠盖住较大空牛棚连续列的方法无法获得最优解,我们也应该尽量贪心那些距离小的木板合并。 如果仍有一个空牛棚连续列与我们的答案盖住的那个相同,我们同样使用上述的方法。会发现获得的新解与原解相同,那么不论我们选哪个,结果都将一样。 由此可见,如果我们合并的两块木板间距离最短,那么总能获得最优解。所以,在解题的每一步中,我们都只需要寻找两块距离最小的木板并合并它们。这样,我们获得的解必定最优。 结论: 如果有贪心性质存在,那么一定要采用!因为它容易编写,容易调试,速度极快,并且节约空间。几乎可以说,它是所有算法中最好的。但是应该注意,别陷入证明不正确贪心性质的泥塘中无法自拔,因为贪心算法的适用范围并不大,而且有一部分极难证明,若是没有把握,最好还是不要冒险,因为还有其他算法会比它要保险。 类似问题: 三值排序问题 [IOI 1996] 有一个由N个数值均为123的数构成的序列(N<= 1000),其值无序,现要求你用最少的交换次数将序列按升序顺序排列。 算法:排序后的序列分为三个部分:排序后应存储1的部分,排序后应存储2的部分和排序后应存储3的部分,贪心排序法应交换尽量多的交换后位置正确的(21)、(31)和(32)数对。当这些数对交换完毕后,再交换进行两次交换后位置正确的(123)三个数。 分析:很明显,每一次交换都可以改变两个数的位置,若经过一次交换以后,两个数的位置都由错误变为了正确,那么它必定最优。同时我们还可发现,经过两次交换后,我们可以随意改变3个数的位置。那么如果存在三个数恰好为123,且位置都是错误的,那么进行两次交换使它们位置正确也必定最优。有由于该题具有最优子结构性质,我们的贪心算法成立。 货币系统 -- 一个反例 [已删节] 奶牛王国刚刚独立,王国中的奶牛们要求设立一个货币系统,使得这个货币系统最好。现在告诉你一个货币系统所包含的货币面额种类(假设全为硬币)以及所需要找的钱的大小,请给出用该货币系统找出该钱数,并且要求硬币数尽量少。 算法:每次都选择面额不超过剩余钱数但却最大的一枚硬币。例如:有货币系统为{12510},要求找出16,那么第一次找出10,第二次找出5,第三次找出1,恰好为最优解。 错误分析: 其实可以发现,这种算法并不是每一次都能构成最优解。反例如:货币系统{15810},同样找16,贪心的结果是1051三枚,但用两枚8的硬币才是最优解。因为这样,贪心的性质不成立,如此解题也是错的。 拓扑排序 给你一些物品的集合,然后给你一些这些物品的摆放顺序的约束,如"物品A应摆放在物品B",请给出一个这些物品的摆放方案,使得所有约束都可以得到满足。 算法:对于给定的物品创建一个有向图,AB的弧表示"物品A应摆放在物品B。以任意顺序对每个物品进行遍历。每当你找到一个物品,他的入度为0,那么贪心地将它放到当前序列的末尾,删除它所有的出弧,然后对它的出弧指向的所有结点进行递归,用同样的算法。如果这个算法遍历了所有的物品,但却没有把所有的物品排序,那就意味着没有满足条件的解。

Greedy Algorithm Greedy Algorithm Sample Problem: Barn Repair [1999 USACO Spring Open] There is a long list of stalls, some of which need to be covered with boards. You can use up to N (1 <= N <= 50) boards, each of which may cover any number of consecutive stalls. Cover all the necessary stalls, while covering as few total stalls as possible. The Idea The basic idea behind greedy algorithms is to build large solutions up from smaller ones. Unlike other approaches, however, greedy algorithms keep only the best solution they find as they go along. Thus, for the sample problem, to build the answer for N = 5, they find the best solution for N = 4, and then alter it to get a solution for N = 5. No other solution for N = 4 is ever considered. Greedy algorithms are fast, generally linear to quadratic and require little extra memory. Unfortunately, they usually aren't correct. But when they do work, they are often easy to implement and fast enough to execute. Problems There are two basic problems to greedy algorithms. How to Build How does one create larger solutions from smaller ones? In general, this is a function of the problem. For the sample problem, the most obvious way to go from four boards to five boards is to pick a board and remove a section, thus creating two boards from one. You should choose to remove the largest section from any board which covers only stalls which don't need covering (so as to minimize the total number of stalls covered). To remove a section of covered stalls, take the board which spans those stalls, and make into two boards: one of which covers the stalls before the section, one of which covers the stalls after the section. Does it work? The real challenge for the programmer lies in the fact that greedy solutions don't always work. Even if they seem to work for the sample input, random input, and all the cases you can think of, if there's a case where it won't work, at least one (if not more!) of the judges' test cases will be of that form. For the sample problem, to see that the greedy algorithm described above works, consider the following: Assume that the answer doesn't contain the large gap which the algorithm removed, but does contain a gap which is smaller. By combining the two boards at the end of the smaller gap and splitting the board across the larger gap, an answer is obtained which uses as many boards as the original solution but which covers fewer stalls. This new answer is better, so therefore the assumption is wrong and we should always choose to remove the largest gap. If the answer doesn't contain this particular gap but does contain another gap which is just as large, doing the same transformation yields an answer which uses as many boards and covers as many stalls as the other answer. This new answer is just as good as the original solution but no better, so we may choose either. Thus, there exists an optimal answer which contains the large gap, so at each step, there is always an optimal answer which is a superset of the current state. Thus, the final answer is optimal. Conclusions If a greedy solution exists, use it. They are easy to code, easy to debug, run quickly, and use little memory, basically defining a good algorithm in contest terms. The only missing element from that list is correctness. If the greedy algorithm finds the correct answer, go for it, but don't get suckered into thinking the greedy solution will work for all problems. Sample Problems Sorting a three-valued sequence [IOI 1996] You are given a three-valued (1, 2, or 3) sequence of length up to 1000. Find a minimum set of exchanges to put the sequence in sorted order. Algorithm The sequence has three parts: the part which will be 1 when in sorted order, 2 when in sorted order, and 3 when in sorted order. The greedy algorithm swaps as many as possible of the 1's in the 2 part with 2's in the 1 part, as many as possible 1's in the 3 part with 3's in the 1 part, and 2's in the 3 part with 3's in the 2 part. Once none of these types remains, the remaining elements out of place need to be rotated one way or the other in sets of 3. You can optimally sort these by swapping all the 1's into place and then all the 2's into place. Analysis: Obviously, a swap can put at most two elements in place, so all the swaps of the first type are optimal. Also, it is clear that they use different types of elements, so there is no ``interference'' between those types. This means the order does not matter. Once those swaps have been performed, the best you can do is two swaps for every three elements not in the correct location, which is what the second part will achieve (for example, all the 1's are put in place but no others; then all that remains are 2's in the 3's place and vice-versa, and which can be swapped). Friendly Coins - A Counterexample [abridged] Given the denominations of coins for a newly founded country, the Dairy Republic, and some monetary amount, find the smallest set of coins that sums to that amount. The Dairy Republic is guaranteed to have a 1 cent coin. Algorithm: Take the largest coin value that isn't more than the goal and iterate on the total minus this value. (Faulty) Analysis: Obviously, you'd never want to take a smaller coin value, as that would mean you'd have to take more coins to make up the difference, so this algorithm works. Maybe not: Okay, the algorithm usually works. In fact, for the U.S. coin system {1, 5, 10, 25}, it always yields the optimal set. However, for other sets, like {1, 5, 8, 10} and a goal of 13, this greedy algorithm would take one 10, and then three 1's, for a total of four coins, when the two coin solution {5, 8} also exists. Topological Sort Given a collection of objects, along with some ordering constraints, such as "A must be before B," find an order of the objects such that all the ordering constraints hold. Algorithm: Create a directed graph over the objects, where there is an arc from A to B if "A must be before B." Make a pass through the objects in arbitrary order. Each time you find an object with in-degree of 0, greedily place it on the end of the current ordering, delete all of its out-arcs, and recurse on its (former) children, performing the same check. If this algorithm gets through all the objects without putting every object in the ordering, there is no ordering which satisfies the constraints.

 

 

 

0

 

 

2017-03-18 11:19:08

1

64

N

4

4

0

1023

USACO教程:Search Techniques搜索方式

样例: n 皇后问题 [经典问题]  n 个皇后摆放在一个 n x n 的棋盘上,使得每一个皇后都无法攻击到其他皇后。 深度优先搜索 (DFS) 显而易见,最直接的方法就是把皇后一个一个地摆放在棋盘上的合法位置上,枚举所有可能寻找可行解。可以发现在棋盘上的每一行(或列)都存在且仅存在一个皇后,所以,在递归的每一步中,只需要在当前行(或列)中寻找合法格,选择其中一个格摆放一个皇后。 1 search(col) 2 if filled all columns 3 print solution and exit 4 for each row 5 if board(row, col) is not attacked 6 place queen at (row, col) 7 search(col+1) 8 remove queen at (row, col) search(0)开始搜索,由于在每一步中可选择的节点较少,该方法可以较快地求解:当一定数量的皇后被摆放在棋盘上后那些不会被攻击到的节点的数量将迅速减少。 这是深度优先搜索的一个经典例题,该算法总是能尽可能快地抵达搜索树的底层:当 k 个皇后被摆放到棋盘上时,可以马上确定如何在棋盘上摆放下一个皇后,而不需要去考虑其他的顺序摆放皇后可能造成的影响(如当前情况是否为最优情况),该方法有时可以在找到可行解之前避免复杂的计算,这是十分值得的。 深度优先搜索具有一些特性,考虑下图的搜索树: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1023rec1.gif> 该算法用逐步加层的方法搜索并且适当时回溯,在每一个已被访问过的节点上标号,以便下次回溯时不会再次被搜索。绘画般地,搜索树将以如下顺序被遍历: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1023rec2.gif> 复杂度: 假设搜索树有 d 层(在样例中 d=n ,即棋盘的列数)。再假设每一个节点都有 c 个子节点(在样例中,同样 c=n ,即棋盘的行数,但最后一层没有子节点,除外)。那么整个搜索花去的时间将与 cd 成正比,是指数级的。但是其需要的空间较小,除了搜索树以外,仅需要用一个栈存储当前路径所经过的节点,其空间复杂度为 O(d) 。 样例:骑士覆盖问题[经典问题] 在一个 n x n 的棋盘中摆放尽量少的骑士,使得棋盘的每一格都会被至少一个骑士攻击到。但骑士无法攻击到它自己站的位置. 广度优先搜索 (BFS) 在这里,最好的方法莫过于先确定 k 个骑士能否实现后再尝试 k+1 个骑士,这就叫广度优先搜索。通常,广度优先搜索需用队列来帮助实现。 1 process(state) 2 for each possible next state from this one 3 enqueue next state 4 search() 5 enqueue initial state 6 while !empty(queue) 7 state = get state from queue 8 process(state) 广度优先搜索得名于它的实现方式:每次都先将搜索树某一层的所有节点全部访问完毕后再访问下一层, 再利用先前的那颗搜索树,广度优先搜索以如下顺序遍历: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1023rec3.gif> 首先访问根节点,而后是搜索树第一层的所有节点,之后第二层、第三层……以此类推。 复杂度: 广度优先搜索所需的空间与深度优先搜索所需的不同( n 皇后问题的空间复杂度为 O(n) ,广度优先搜索的空间复杂取决于每层的节点数。如果搜索树有 k 层,每个节点有 c 个子节点,那么最后将可能有 c k 个数据被存入队列,这个复杂度无疑是巨大的。所以在使用广度优先搜索时,应小心处理空间问题。 迭代加深搜索 (ID) 广度优先搜索可以用迭代加深搜索代替。迭代加深搜索实质是限定下界的深度优先搜索,即首先允许深度优先搜索搜索 k 层搜索树,若没有发现可行解,再将 k+1 后再进行一次以上步骤,直到搜索到可行解。这个模仿广度优先搜索搜索法比起广搜是牺牲了时间,但节约了空间。 1 truncated_dfsearch(hnextpos, depth) 2 if board is covered 3 print solution and exit 4 if depth == 0 5 return 6 for i from nextpos to n*n 7 put knight at i 8 truncated_dfsearch(i+1, depth-1) 9 remove knight at i 10 dfid_search 11 for depth = 0 to max_depth 12 truncated_dfsearch(0, depth) 复杂度:   ID时间复杂度与DFS的时间复杂度(O(n))不同,另一方面,它要更复杂,某次DFS若限界 k 层,则耗时 ck 。若搜索树共有 d 层,则一个完整的DFS-ID将耗时 c0 + c1 + c2 + ... + cd 。如果 c = 2 ,那么式子的和是 cd+1 - 1 ,大约是同效BFS的两倍。当 c > 2 时(子节点的数目大于2),差距将变小:ID的时间消耗不可能大于同效BFS的两倍。 所以,但数据较大时,ID-DFS并不比BFS慢,但是空间复杂度却与DFS相同,比BFS小得多。 算法选择: 当你已经知道某题是一道搜索题,那么选择正确的搜索方式是十分重要的。下面给你一些选择的依据。 简表: 搜索方式 时间 空间 使用情况 DFS O(c k) O(k) 必须遍历整棵树,要求出解的深度或经的过节点,或者你并不需要解的深度最小。 BFS O(c d ) O(c d ) 了解到解十分靠近根节点,或者你需要解的深度最小。 DFS+ID O(c d) O(d) 需要做BFS,但没有足够的空间,时间却很充裕。 d :解的深度 k :搜索树的深度 d <= k 记住每一种搜索法的优势。如果要求求出最接近根节点的解,则使用BFDID。而如果是其他的情况,DFS是一种很好的搜索方式。如果没有足够的时间搜出所有解。那么使用的方法应最容易搜出可行解,如果答案可能离根节点较近,那么就应该用BFSID,相反,如果答案离根节点较远,那么使用DFS较好。还有,请仔细小心空间的限制。如果空间不足以让你使用BFS,那么请使用迭代加深吧! 类似问题: 超级质数肋骨[USACO 1994 决赛] 一个数,如果它从右到左的一位、两位直到N位(N是)所构成的数都是质数,那么它就称为超级质数。例如:233232都是质数,所以233是超级质数。要求:读入一个数NN <= 9),编程输出所有有N位的超级质数。 这题应使用DFS,因为每一个答案都有N层(最底层),所以DFS是最好的. Betsy的旅行 [USACO 1995 资格赛] 一个正方形的小镇被分成 NxN (2 <= N <= 6)个小方格,Besty 要从左上角的方格到达左下角的方格,并且经过每一次方格都恰好经过一次。编程对于给定的 N 计算出 Besty 能采用的所有的旅行路线的数目。 这题要求求出解的数量,所以整颗搜索树都必须被遍历,这就与可行解的位置与出解速度没有关系了。所以这题可以使用BFSDFS,又因为DFS需要的空间较少,所以DFS是较好的. 奶牛运输 [USACO 1995 决赛] 奶牛运输公司拥有一辆运输卡车与牧场 A ,运输公司的任务是在ABCDEFG七个农场之间运输奶牛。每两个农场之间的路程(可以用floyed改变)已给出。每天早晨,运输公司都必须确定一条运输路线,使得运输的总距离最短。但必须遵守以下规则: 农场 A 是公司的基地。每天的运输都必须从这开始并且在这结束。 卡车任何时刻都只能最多承载一头奶牛。 给出的数据是奶牛的原先位置与运输结束后奶牛所在的位置。 而你的任务是在上述规则内寻找最短的运输路线。 在发现最优解时必须比较所有可行解,所以必须遍历整棵搜索树。所以,可以用DFS解题. 横越沙漠 [1992 IOI] 一群沙漠探险者正尝试着让他们中的一部分人横渡沙漠。每一个探险者可以携带一定数量的水,同时他们每天也要喝掉一定量的水。已知每个探险者可携带的水量与每天需要的水量都不同。给出每个探险者能携带的水量与需要的水量与横渡沙漠所需的天数,请编程求出最多能有几个人能横渡沙漠。所有探险者都必须存活,所以有些探险者在中途必须返回,返回时也必须携带足够的水。当然,如果一个探险者返回时有剩余的水(除去返回所需的水以外),他可以把剩余的水送给他的一个同伴,如果它的同伴可以携带的话。 这题可以分成两个小问题,一个是如何为探险者分组,另一个是某些探险者应在何处返回。所以使用ID-DFS是可行的。首先尝试每一个探险者能否独自横渡,然后是两个人配合,三个人配合。直到结束。

Crafting Winning Solutions A good way to get a competitive edge is to write down a game plan for what you're going to do in a contest round. This will help you script out your actions, in terms of what to do both when things go right and when things go wrong. This way you can spend your thinking time in the round figuring out programming problems and not trying to figure out what the heck you should do next... it's sort of like precomputing your reactions to most situations. Mental preparation is also important. Game Plan For A Contest Round Read through ALL the problems FIRST; sketch notes with algorithm, complexity, the numbers, data structs, tricky details, ... Brainstorm many possible algorithms - then pick the stupidest that works! DO THE MATH! (space & time complexity, and plug in actual expected and worst case numbers) Try to break the algorithm - use special (degenerate?) test cases Order the problems: shortest job first, in terms of your effort (shortest to longest: done it before, easy, unfamiliar, hard) Coding a problem - For each, one at a time: Finalize algorithm Create test data for tricky cases Write data structures Code the input routine and test it (write extra output routines to show data?) Code the output routine and test it Stepwise refinement: write comments outlining the program logic Fill in code and debug one section at a time Get it working & verify correctness (use trivial test cases) Try to break the code - use special cases for code correctness Optimize progressively - only as much as needed, and keep all versions (use hard test cases to figure out actual runtime) Time management strategy and "damage control" scenarios Have a plan for what to do when various (foreseeable!) things go wrong; imagine problems you might have and figure out how you want to react. The central question is: "When do you spend more time debugging a program, and when do you cut your losses and move on?". Consider these issues: How long have you spent debugging it already? What type of bug do you seem to have? Is your algorithm wrong? Do you data structures need to be changed? Do you have any clue about what's going wrong? A short amount (20 mins) of debugging is better than switching to anything else; but you might be able to solve another from scratch in 45 mins. When do you go back to a problem you've abandoned previously? When do you spend more time optimizing a program, and when do you switch? Consider from here out - forget prior effort, focus on the future: how can you get the most points in the next hour with what you have? Have a checklist to use before turning in your solutions: Code freeze five minutes before end of contest? Turn asserts off. Turn off debugging output. Tips & Tricks Brute force it when you can KISS: Simple is smart! Hint: focus on limits (specified in problem statement) Waste memory when it makes your life easier (if you can get away with it) Don't delete your extra debugging output, comment it out Optimize progressively, and only as much as needed Keep all working versions! Code to debug: whitespace is good, use meaningful variable names, don't reuse variables, stepwise refinement, COMMENT BEFORE CODE. Avoid pointers if you can Avoid dynamic memory like the plague: statically allocate everything. Try not to use floating point; if you have to, put tolerances in everywhere (never test equality) Comments on comments: Not long prose, just brief notes Explain high-level functionality: ++i; /* increase the value of i by */ is worse than useless Explain code trickery Delimit & document functional sections As if to someone intelligent who knows the problem, but not the code Anything you had to think about Anything you looked at even once saying, "now what does that do again?" Always comment order of array indices Keep a log of your performance in each contest: successes, mistakes, and what you could have done better; use this to rewrite and improve your game plan! Complexity Basics and order notation The fundamental basis of complexity analysis revolves around the notion of ``big oh'' notation, for instance: O(N). This means that the algorithm's execution speed or memory usage will double when the problem size doubles. An algorithm of O(N 2) will run about four times slower (or use 4x more space) when the problem size doubles. Constant-time or space algorithms are denoted O(1). This concept applies to time and space both; here we will concentrate discussion on time. One deduces the O() run time of a program by examining its loops. The most nested (and hence slowest) loop dominates the run time and is the only one mentioned when discussing O() notation. A program with a single loop and a nested loop (presumably loops that execute N times each) is O(N 2), even though there is also a O(N) loop present. Of course, recursion also counts as a loop and recursive programs can have orders like O(b N), O(N!), or even O(N N). Rules of thumb When analyzing an algorithm to figure out how long it might run for a given dataset, the first rule of thumb is: modern (2004) computers can deal with 100M actions per second. In a five second time limit program, about 500M actions can be handled. Really well optimized programs might be able to double or even quadruple that number. Challenging algorithms might only be able to handle half that much. Current contests usually have a time limit of 1 second for large datasets. 16MB maximum memory use 210 ~approx~ 10 3 If you have k nested loops running about N iterations each, the program has O(N k) complexity. If your program is recursive with b recursive calls per level and has l levels, the program O(b l) complexity. Bear in mind that there are N! permutations and 2 n subsets or combinations of N elements when dealing with those kinds of algorithms. The best times for sorting N elements are O(N log N). DO THE MATH! Plug in the numbers. Examples A single loop with N iterations is O(N): 1 sum = 0 2 for i = 1 to n 3 sum = sum + i A double nested loop is often O(N 2): # fill array a with N elements 1 for i = 1 to n-1 2 for j = i + 1 to n 3 if (a[i] > a[j]) swap (a[i], a[j]) Note that even though this loop executes N x (N+1) / 2 iterations of the if statement, it is O(N 2) since doubling N quadruples the execution times. Consider this well balanced binary tree with four levels: An algorithm that traverses a general binary tree will have complexity O(2 N). Solution Paradigms Generating vs. Filtering Programs that generate lots of possible answers and then choose the ones that are correct (imagine an 8-queen solver) are filters. Those that hone in exactly on the correct answer without any false starts are generators. Generally, filters are easier (faster) to code and run slower. Do the math to see if a filter is good enough or if you need to try and create a generator. Precomputation Sometimes it is helpful to generate tables or other data structures that enable the fastest possible lookup of a result. This is called precomputation (in which one trades space for time). One might either compile precomputed data into a program, calculate it when the program starts, or just remember results as you compute them. A program that must translate letters from upper to lower case when they are in upper case can do a very fast table lookup that requires no conditionals, for example. Contest problems often use prime numbers - many times it is practical to generate a long list of primes for use elsewhere in a program. Decomposition (The Hardest Thing At Programming Contests) While there are fewer than 20 basic algorithms used in contest problems, the challenge of combination problems that require a combination of two algorithms for solution is daunting. Try to separate the cues from different parts of the problem so that you can combine one algorithm with a loop or with another algorithm to solve different parts of the problem independently. Note that sometimes you can use the same algorithm twice on different (independent!) parts of your data to significantly improve your running time. Symmetries Many problems have symmetries (e.g., distance between a pair of points is often the same either way you traverse the points). Symmetries can be 2-way, 4-way, 8-way, and more. Try to exploit symmetries to reduce execution time. For instance, with 4-way symmetry, you solve only one fourth of the problem and then write down the four solutions that share symmetry with the single answer (look out for self-symmetric solutions which should only be output once or twice, of course). Forward vs. Backward Surprisingly, many contest problems work far better when solved backwards than when using a frontal attack. Be on the lookout for processing data in reverse order or building an attack that looks at the data in some order or fashion other than the obvious. Simplification Some problems can be rephrased into a somewhat different problem such that if you solve the new problem, you either already have or can easily find the solution to the original one; of course, you should solve the easier of the two only. Alternatively, like induction, for some problems one can make a small change to the solution of a slightly smaller problem to find the full answer.

 

 

 

0

 

 

2017-03-18 11:19:08

1

64

N

3

3

0

1024

USACO_2.1-1:The Castle城堡IOI'94-Day1

以一个几乎超乎想像的运气,农民约翰在他的生日收到了一张爱尔兰博彩的奖券。 这一张奖券成为了唯一中奖的奖券。 农民约翰嬴得爱尔兰的乡下地方的一个传说中的城堡。 吹牛在他们威斯康辛州不算什么,农民约翰想告诉他的牛所有有关城堡的事。 他想知道城堡有多少房间,而且最大的房间有多大。 事实上,他想去掉一面墙来制造一个更大的房间。 你的任务是帮助农民约翰去了解正确房间数目和大小。 城堡的平面图被分为 M(wide)*N(1 <=M,N<=50)个小正方形。 每个这样的小正方形有04面墙。 城堡在它的外部边缘总是有墙壁的,好遮挡风雨。 考虑这注解了一个城堡的平面图:<img src="/JudgeOnline/upload/image/20170720/20170720153417_64213.png" alt="" />例子的城堡的大小是7 x 4。 一个 "房间"是平面图上有连接的"小正方形"的集合。 这个平面图包含五个房间。(它们的大小是9,7,3,1,  8 排列没有特别的顺序)。 移除被箭作记号的墙壁来合并两个房间来制造最大的可能房间(移除一面墙所能产生的)。 城堡总是至少有二个房间并且总是有一面墙壁以可能被移除。

地图以一个表格来储存,每个数字描述一个小正方形,N行每行M个数来描述这个平面图。 输入顺序符合那个在上面例子的编号方式。 每个描述小正方形的数字说明小正方形的四面的墙的分布情况,它是下面4个数的和: 1: 在西面有墙 2: 在北面有墙 4: 在东面有墙 8: 在南面有墙 内部的墙壁是会被定义两次;小正方形(1,1)南面的墙也被指出是小正方形(2,1)北面的墙。 第 1 : 二个被空格分开的整数: M  N  2  N+1 : M x N 个整数,每行M个。

输出包含一些行:  1 : 城堡的房间数目。 第 2 : 最大的房间的大小 第 3 : 移除一面墙能得到的最大的房间的大小 第 4 : 移除哪面墙 选择最佳的墙来移除,(选择最靠西的,如果仍然不能确定,再选择最靠南的。编者注:墙的位置应该由它的中点来定义) (【原文】Choose the optimal wall to remove from the set of optimal walls by choosing the wall farther to the west (and then, if still tied, farthest to the south).) 墙壁由它在相邻的小正方形的西部或南方来命名

7 4 11 6 11 6 3 10 6 7 9 6 13 5 15 5 1 10 12 7 13 7 5 13 11 10 8 10 12 13

5 9 16 4 1 E

0

 

USACO_2.1-1

2017-07-20 15:34:23

1

64

N

2

3

0

1025

USACO_2.1-2:Ordered Fractions顺序的分数

输入一个自然数N  请写一个程序来增序输出分母小于等于N的既约真分数

单独的一行 一个自然数N(1..160)

每个分数单独占一行

5

0/1 1/5 1/4 1/3 2/5 1/2 3/5 2/3 3/4 4/5 1/1

0

 

USACO_2.1-2

2017-03-18 11:19:08

1

64

N

1

3

0

1026

TJU_P1001:排版题.输出排列成菱形的字母

输入N值,编程输出如下图形。

一个整数N1<=N<=7)。

排列成菱形的大写字符,首字符为Z,以后依次为Y,X...

3

Z Y X W V U T S

0

 

TJU_P1001

2017-03-18 11:19:08

1

64

N

0

1

0

1027

选自黄皮书:排版题.输出排列成三角形的字母

输入一个N1<=N<=26),输出由大写字母构成的三角形,字母递增从A开始。 如:N3 A A B A B C

输入N1<=N<=26)。

由大写字母构成的三角形。

3

A A B A B C

0

 

选自黄皮书

2017-03-18 11:19:08

1

64

N

0

2

0

1028

TJU_P1008:排版题.扬辉三角

输出扬辉三角

本题有测试数据,每组数据仅含一个整数N(N不大于34)。一组数据独占一行。

对于每一组数据,先输出一个 Case #: 其中#号代表第#组数据。接下来输出一个由数字组成的扬辉三角。一行中的数字之间用一个空格分开。行尾不要有多余的空格。 两组数据之间空开一行。

6 3

Case 1: 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 Case 2: 1 1 1 1 2 1

0

 

TJU_P1008

2017-03-18 11:19:08

1

64

N

2

4

0

1029

TJU_P1009:排版题.蛇行矩阵

蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。

本题有多组数据,每组数据由一个正整数N组成。(N不大于100

对于每一组数据,输出一个N行的蛇形矩阵。两组输出之间不要额外的空行。 矩阵三角中同一行的数字用一个空格分开。行尾不要多余的空格。

5

1 3 6 10 15 2 5 9 14 4 8 13 7 12 11

0

 

TJU_P1009

2017-03-18 11:19:08

1

64

N

2

4

0

1030

TJU_P1012:约瑟夫问题

将编号为1,2,...,NN个人按顺时针方向围坐一圈,每人持有一个密码(10000以内的正整数)。一开始任选一个正整数作为报数上限值M,从第一个开始按顺时针方向自1开始报数,报到M时停止报数。报M的人出列,将他的密码作为新的M值,从他在顺时针方向上的下一个人开始重新从1报数,如此下去,直至所有人全部出列为止。试设计一个程序求出出列顺序。

本题有多组数据。 每组数据的第一行是两个整数NM ; 其中NM均大于0且小于100。 第二行是N个正整数,分别表示1N个人持有的密码。 两组数据之间空开一行。

对每组数据,按离开的顺序输出他们的编号。数字之间用一个空格分开。每组数据独占一行输出。

7 20 3 1 7 2 4 8 4 4 3 1 2 3 4

6 1 4 7 2 3 5 3 2 1 4

0

 

TJU_P1012

2017-03-18 11:19:08

1

64

N

0

4

0

1031

TJU_P1007:Step.如何得到输入数据的结束

Step 大家好!我是kaikai。 在Online Judge上,有的题目具有不确定的数据量。并且也没有特别指出哪个符号是表示数据的结束。这种情况下如何才能正确的得到数据? 使用EOF!对,你的想法是正确的。 while(scanf("%d",&a)!=EOF) { ... } 当然你也可以利用scanf的返回值。 while(scanf("%d",&a)==1) { ... } Free Pascal下面的代码: program p(Input,Output); begin while not seekeof(Input) do begin ... end; end. NOTE, SeekEof函数不是标准pascal函数库中的,使用SeekEof函数在GNU Pascal下不能通过编译。 这2种方法的效果是一样的。下面来试试看。 Program 对输入的整数求和。所有的整数都不大于100

整数若干。每行一个。

一个整数,表示所有输入整数的和。

1 3 2 5 7

18

0

Programming Steps

TJU_P1007

2017-03-18 12:03:24

1

64

N

3

4

0

1032

TJU_P1005:母牛生小牛

设有一头小母牛,从出生第四年起每年生一头小母牛,按此规律,第N年时有几头母牛?

本题有多组数据。每组数据只有一个整数N,独占一行。(1≤N≤50)

对每组数据,输出一个整数(独占一行)表示第N年时母牛的数量

1 4 5 20

1 2 3 872

0

 

TJU_P1005

2017-03-18 12:03:24

1

64

N

3

7

0

1033

TJU_P1006:敲七

输出77的倍数,还有包含7的数字例如(172737...70717273...

一个整数N(N不大于30000)

从小到大排列的不大于N的与7有关的数字,每行一个。

20

7 14 17

0

careful n!

TJU_P1006

2017-03-18 12:03:24

1

64

N

2

3

0

1034

TJU_P1004:防御导弹

某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够达到任意的高度,但是以后每一发炮弹都不能高于前一发的高度。某天,雷达捕捉到敌国的导弹来袭。由于该系统还在使用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹。

最多20个整数,分别表示导弹依次飞来的高度(雷达给出高度数据是不大于30000的正整数)

两个整数MN。表示:这套系统最多能拦截 M 枚导弹,如果要拦截所有导弹最少要配备 N 套这种导弹系统。

300 250 275 252 200 138 245

5 2

0

 

TJU_P1004

2017-03-18 12:03:24

1

64

N

2

3

0

1035

TJU_P1010:数素数

素数是的只能被1和它本身整除的自然数。判断一个数是素数的方法是使用2到该数的平方根的素数除它,若有能整除的则该数不是素数。

本题有多组数据,每组数据由两个正整数M,N组成。(0MN1000000

输出一个整数,表示介于M,N之间(包括M,N)的素数的数量。

5 10 1 3 6 8

2 2 1

0

 

TJU_P1010

2017-03-18 12:03:24

5

64

N

2

3

0

1036

TJU_P1002:全排序问题

将一个字符组全排序

一个长度小于10的字符串,该字符串由数字19组成。字符不会重复出现。

按数字在输入串中出现的次序从小到大的顺序输出该字符组的全排序

132

1 3 2 1 2 3 3 1 2 3 2 1 2 1 3 2 3 1

0

 

TJU_P1002

2017-03-18 12:03:24

5

64

N

1

5

0

1037

NOIP_2000.PJ1:计算器的改良

NCL是一家专门从事计算器改良与升级的实验室,最近该实验室收到了某公司所委托的一个任务: 需要在该公司某型号的计算器上加上解一元一次方程的功能。 实验室将这个任务交给了一个刚进入的新手ZL先生。 为了很好的完成这个任务,ZL先生首先研究了一些一元一次方程的实例: 4+3x=8 6a-5+1=2-2a -5+12Y=0 ZL先生被主管告之,在计算器上键入的一个一元一次方程中,只包含整数、小写字母 及十、一、=这三个数学符号(当然,符号既可作减号,也可作负号)。 方程中并没有括号,也没有除号,方程中的字母表示未知数。 问题求解: 编写程序,解输入的一元一次方程,将解方程的结果(精确至小数点后三位)输出至屏幕。 你可假设对键入的方程的正确性的判断是由另一个程序员在做,或者说可认为键入的一元一次方程均为合法的,且有唯一实数解。

一个字符串,表示求解的方程

<p> 解方程的结果(精确至小数点后三位) </p> <p> <br /> </p>

6a-5+1=2-2a

a=0.750

0

 

NOIP_2000.PJ1

2017-07-20 16:13:29

1

64

N

9

19

0

1038

NOIP_2000.PJ2:税收与补贴问题

每样商品的价格越低,其销量就会相应增大。 现已知某种商品的成本及其在若干价位上的销量(产品不会低于成本销售),并假设相邻价位间销量的变化是线性的且在价格高于给定的最高价位后,销量以某固定数值递减。(我们假设价格及销售量都是整数) 对于某些特殊商品,不可能完全由市场去调节其价格。这时候就需要政府以税收或补贴的方式来控制。(所谓税收或补贴就是对于每个产品收取或给予生产厂家固定金额的货币) 问题求解: 你是某家咨询公司的项目经理,现在你已经知道政府对某种商品的预期价格,以及在各种价位上的销售情况。 要求你确定政府对此商品是应收税还是补贴的最少金额(也为整数),才能使商家在这样一种政府预期的价格上,获取相对其他价位上的最大总利润。 总利润=单位商品利润*销量 单位商品利润=单位商品价格-单位商品成本(-税金 or +补贴)

输入的第一行为政府对某种商品的预期价, 第二行有两个整数,第一个整数为商品成本,第二个整数为以成本价销售时的销售量, 以下若干行每行都有两个整数,第一个为某价位时的单价,第二个为此时的销量, 以一行-1-1表示所有已知价位及对应的销量输入完毕, 输入的最后一行为一个单独的整数表示在已知的最高单价外每升高一块钱将减少的销量。

输出有两种情况: 若在政府预期价上能得到最大总利润,则输出一个单独的整数, 数的正负表示是补贴还是收税, 数的大小表示补贴或收税的金额最小值。 若有多解,取绝对值最小的输出。 如在政府预期价上不能得到最大总利润,则输出“NO SOLUTION”

31 28 130 30 120 31 110 -1 -1 15

4

0

 

NOIP_2000.PJ2

2017-03-18 12:03:24

1

64

N

4

5

0

1039

NOIP_2000.PJ3:乘积最大

今年是国际数学联盟确定的“2000——世界数学年, 又恰逢我国著名数学家华罗庚先生诞辰90周年。 在华罗庚先生的家乡江苏金坛,组织了一场别开生面的数学智力竞赛的活动,你的一个好朋友XZ也有幸得以参加。 活动中,主持人给所有参加活动的选手出了这样一道题目: 设有一个长度N的数字串,要求选手使用K个乘号将它分成K+1个部分, 找出一种分法,使得这K+1个部分的乘积能够为最大。 同时,为了帮助选手能够正确理解题意, 主持人还举了如下的一个例子: 有一个数字串: 312, 当N=3K=1时会有以下两种分法: 13*12=36 231*2=62 这时,符合题目要求的结果是: 31*2=62 现在,请你帮助你的好朋友XZ设计一个程序,求得正确的答案。

程序的输入共有两行: 第一行共有2个自然数N,K (6<=N<=401<=K<=6) 第二行是一个K度为N的数字串。

结果显示在屏幕上,相对于输入,应输出所求得的最大乘积(一个自然数)。

4 2 1231

62

0

 

NOIP_2000.PJ3

2017-03-18 12:03:24

1

64

N

4

5

0

1040

NOIP_2000.PJ4:单词接龙

单词接龙是一个与我们经常玩的成语接龙相类似的游戏,现在我们己知一组单词,且给定一个开头的字母,要求出以这个字母开头的最长的(每个单词都最多在" 中出现两次),在两个单词相连时,其重合部分合为一部分,例如beastastonish,如果接成一条龙则变为beastonish,另外相邻的两部分不能存在包含关系,例如atatide间不能相连。

输入的第一行为一个单独的整数n(n<=20)表示单词数,以下n行每行有一个单词,输入的最后一行为一个单个字符,表来开头的字母。你可以假定以此字母开头的" 一定存在。

只需输出以此字母开头的最长的的长度

5 at touch cheat choose tact a

23 (连成的atoucheatactactouchoose

0

 

NOIP_2000.PJ4

2017-03-18 12:03:24

1

64

N

4

7

0

1041

NOIP_2001.PJ1:数的计数

我们要求找出具有下列性质数的个数(包含输入的自然数n): 先输入一个自然数n(n≤1000),然后对此自然数按照如下方法进行处理 l•不作任何处理: 2•茬它的左边加上一个自然数,但该自然数不能超过原数的一半; 3•加上数后,继续按此规则进行处理,直到不能再而 自然数为止。

输入:6 (满足条件的数为616 26 126 36 136 (此部分不必输出

输出:6

6

6

0

【高精度】

NOIP_2001.PJ1

2017-07-20 16:16:07

1

64

N

6

9

0

1042

NOIP_2001.PJ2:最大公约数与最小公倍数问题

输入二个正整数x0,y0(2≤x0≤1000002≤y0≤1000000),求出满足下列条件的PQ的个数。 条件:1.PQ是正整数 2.要求PQxO为最大公约数,以yO为最小公倍数。 试求,满足条件的所有可能的两个正整数的个数。

一行,两个整数x0y0

<p> 输出:<span style="color:#333333;font-family:"font-size:14px;background-color:#EEEEEE;">满足条件的所有可能的两个正整数的个数</span> </p> <p> <br /> </p>

3 60

4 说明:(不用输出)此时的 P Q 分别为, 3 60 15 12 12 15 60 3 所以,满足条件的所有可能的两个正整数的个数共4种。

0

 

NOIP_2001.PJ2

2017-07-20 16:21:39

1

64

N

5

7

0

1043

NOIP_2001.PJ3:求先序排列

给出一棵二叉树的中序与后序排列。求出它的先序排列。(约定树结点用不同的大写字母表示,长度≤8)

<span style="color:#200000;font-family:"font-size:14px;background-color:#FFFFFF;">一行,两个以空格隔开的字符串,分别表示中序和后序排列</span>

<p> <span style="color:#200000;font-family:"font-size:14px;background-color:#FFFFFF;"> 一个字符串,表示所求先序排列</span> </p>

BADC BDCA

ABCD

0

 

NOIP_2001.PJ3

2017-07-20 15:48:00

1

64

N

3

4

0

1044

NOIP_2001.PJ4:装箱问题

有一个箱子容量为v(正整数,o≤v≤20000),同时有n个物品(o≤n≤30),每个物品有一个体积 (正整数)。要求从 n 个物品中,任取若千个装入箱内,使箱子的剩余空间为最小。

<p> 第一行,一个整数,表示箱子容量   </p> <p> 第二行,一个整数,表示有n个物品。 </p> <p>  接下来n行,分别表示这n个物品的各自体积。 </p>

一个整数,表示箱子剩余空间。

24 6 8 3 12 7 9 7

0

0

 

NOIP_2001.PJ4

2017-07-20 15:51:11

1

64

N

6

12

0

1045

NOIP_2002.PJ1:级数求和

已知:Sn= 112131n。显然对于任意一个整数K,当n足够大的时候,Sn大于K。 现给出一个整数K1<=k<=15),要求计算出一个最小的n;使得SnK

一个整数K

一个整数n

1

2

0

 

NOIP_2002.PJ1

2017-07-20 15:52:34

1

64

N

4

5

0

1046

NOIP_2002.PJ2:选数

已知 n 个整数 x1,x2,…,xn,以及一个整数 kkn)。从 n 个整数中任选 k 个整数相加,可分别得到一系列的和。例如当 n=4k34 个整数分别为 371219 时,可得全部的组合与它们的和为: 3712=22  371929  7121938  3121934。 现在,要求你计算出和为素数共有多少种。 例如上例,只有一种的和为素数:371929)。

<p> 第一行,两个整数nk1<=n<=20kn </p> <p> <span>第二行,n个整数,表示<span> x1,x2…,xn 1<=xi<=5000000</span></span> </p>

 一个整数(满足条件的种数)。

4 3 3 7 12 19

1

0

 

NOIP_2002.PJ2

2017-07-20 15:55:39

1

64

N

2

4

0

1047

NOIP_2002.PJ3:产生数

<p> 给出一个整数 nn<10^30)  k 个变换规则(k<=15)。 规则: 一位数可变换成另一个一位数: 规则的右部不能为零。 </p> <p>  例如:n=234。有规则(k22> 5    3> 6  </p> <p> 上面的整数 234 经过变换后可能产生出的整数为(包括原数): 234    534    264    564  4 种不同的产生数  </p> <p> 问题:给出一个整数 n  k 个规则。 求出经过任意次的变换(0次或多次),能产生出多少个不同整数。(仅要求输出个数。) </p>

<p> 第一行,两个整数nk </p> <p> 接下来2~k+1行,每行两个整数xiyi </p>

一个整数(满足条件的个数)

234 2 2 5 3 6

4

0

 

NOIP_2002.PJ3

2017-07-20 16:03:40

1

64

N

3

5

0

1048

NOIP_2002.PJ4:过河卒

<p> 如图,A 点有一个过河卒,需要走到目标 B 点。卒行走规则:可以向下、或者向右。同时在棋盘上的任一点有一个对方的马(如上图的C点),该马所在的点和所有跳跃一步可达的点称为对方马的控制点。例如上图 C 点上的马可以控制 9 个点(图中的P1P2 … P8  C)。卒不能通过对方马的控制点。 <img src="/JudgeOnline/upload/image/20170720/20170720160752_91036.gif" alt="" /> </p> <p>  棋盘用坐标表示,A 点(00)、B 点(n,m(n,m 为不超过 20 的整数,并由键盘输入),同样马的位置坐标是需要给出的(约定: C<>A,同时C<>B)。现在要求你计算出卒从 A 点能够到达 B 点的路径的条数。 </p>

<p> 一行,四个整数分别为nmxy </p> <p> <span>B点的坐标(n,m)以及对方马的坐标(X,Y     (不用盘错)</span> </p>

一个整数(路径的条数)

6 6 3 2

17

0

 

NOIP_2002.PJ4

2017-07-20 16:23:05

1

64

N

4

20

0

1049

NOIP_2003.PJ1:乒乓球

<p> 【问题背景】国际乒联现在主席沙拉拉自从上任以来就立志于推行一系列改革,以推动乒乓球运动在全球的普及。其中11分制改革引起了很大的争议,有一部分球员因为无法适应新规则只能选择退役。华华就是其中一位,他退役之后走上了乒乓球研究工作,意图弄明白11分制和21分制对选手的不同影响。在开展他的研究之前,他首先需要对他多年比赛的统计数据进行一些分析,所以需要你的帮忙。  </p> <p> 【问题描述】华华通过以下方式进行分析,首先将比赛每个球的胜负列成一张表,然后分别计算在11分制和21分制下,双方的比赛结果(截至记录末尾)。 比如现在有这么一份记录,(其中W表示华华获得一分,L表示华华对手获得一分): WWWWWWWWWWWWWWWWWWWWWWLW 11分制下,此时比赛的结果是华华第一局110获胜,第二局110获胜,正在进行第三局,当前比分11。而在21分制下,此时比赛结果是华华第一局210获胜,正在进行第二局,比分21。如果一局比赛刚开始,则此时比分为00。 你的程序就是要对于一系列比赛信息的输入(WL形式),输出正确的结果。 </p>

每个输入文件包含若干行字符串(每行至多20个字母),字符串由大写的WLE组成。其中E表示比赛信息结束,程序应该忽略E之后的所有内容。

输出由两部分组成,每部分有若干行,每一行对应一局比赛的比分(按比赛信息输入顺序)。其中第一部分是11分制下的结果,第二部分是21分制下的结果,两部分之间由一个空行分隔。

WWWWWWWWWWWWWWWWWWWW WWLWE

11:0 11:0 1:1 21:0 2:1

0

<h4 style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;"> <strong><span style="color:#000000;font-size:14px;font-family:'Microsoft YaHei';">每行最多20个字符<br /> </span></strong><strong><span style="color:#000000;font-size:14px;font-family:'Microsoft YaHei';"> 总共的字符数不超过100000<br /> </span></strong><strong><span style="color:#000000;font-size:14px;font-family:'Microsoft YaHei';">11分制比赛规则:</span></strong><span style="color:#000000;font-family:'Microsoft YaHei';font-size:14px;line-height:24px;background-color:#FFFFFF;"><strong>在一局比赛中,先得11分的一方为胜方;比分出现10平后,先多得2分的方为胜方。</strong></span> </h4>

NOIP_2003.PJ1

2017-07-20 16:27:18

3

64

N

12

26

0

1050

NOIP_2003.PJ2:数字游戏

<p> 丁丁最近沉迷于一个数字游戏之中。这个游戏看似简单,但丁丁在研究了许多天之后却发觉原来在简单的规则下想要赢得这个游戏并不那么容易。游戏是这样的,在你面前有一圈整数(一共n个),你要按顺序将其分为m个部分,各部分内的数字相加,相加所得的m个结果对10取模后再相乘,最终得到一个数k。游戏的要求是使你所得的k最大或者最小。 例如,对于下面这圈数字(n=4m=2): <img src="/JudgeOnline/upload/image/20170720/20170720163019_52680.png" alt="" /> </p> <p>  当要求最小值时,((2-1) mod 10)×((4+3) mod 10)=1×7=7,要求最大值时,为((2+4+3) mod 10)×(-1 mod 10)=9×9=81。特别值得注意的是,无论是负数还是正数,对10取模的结果均为非负值。 丁丁请你编写程序帮他赢得这个游戏。 </p>

输入文件第一行有两个整数,n1≤n≤50)和m1≤m≤9)。 以下n行每行有个整数,其绝对值不大于104,按顺序给出圈中的数字,首尾相接。

输出文件有两行,各包含一个非负整数。 第一行是你程序得到的最小值,第二行是最大值。

4 2 4 3 -1 2

7 81

0

 

NOIP_2003.PJ2

2017-07-20 16:30:29

1

64

N

1

2

0

1051

NOIP_2003.PJ3:

<p> 【问题背景】栈是计算机中经典的数据结构,简单的说,栈就是限制在一端进行插入删除操作的线性表。 栈有两种最重要的操作,即pop(从栈顶弹出一个元素)和push(将一个元素进栈)。 栈的重要性不言自明,任何一门数据结构的课程都会介绍栈。 宁宁同学在复习栈的基本概念时,想到了一个书上没有讲过的问题,而他自己无法给出答案,所以需要你的帮忙。  </p> <p> 【问题描述】 <img src="/JudgeOnline/upload/image/20170720/20170720163248_21781.gif" alt="" />宁宁考虑的是这样一个问题:一个操作数序列,从12,一直到n(图示为13的情况),栈A的深度大于n。 现在可以进行两种操作, 1.将一个数,从操作数序列的头端移到栈的头端(对应数据结构栈的push操作) 2. 将一个数,从栈的头端移到输出序列的尾端(对应数据结构栈的pop操作) 使用这两种操作,由一个操作数序列就可以得到一系列的输出序列,下图所示为由1 2 3生成序列2 3 1的过程。(原始状态如上图所示) <img src="/JudgeOnline/upload/image/20170720/20170720163320_88272.gif" alt="" />你的程序将对给定的n,计算并输出由操作数序列12n经过操作可能得到的输出序列的总数。 </p>

输入文件只含一个整数n1≤n≤18

输出文件只有一行,即可能输出序列的总数目

3

5

0

 

NOIP_2003.PJ3

2017-07-20 16:33:44

1

64

N

4

7

0

1052

【高精度】NOIP_2003.PJ4:麦森数

【问题描述】形如2^P-1的素数称为麦森数,这时P一定也是个素数。但反过来不一定,即如果P是个素数,2^P-1不一定也是素数。 到1998年底,人们已找到了37个麦森数。最大的一个是P=3021377,它有909526位。麦森数有许多重要应用,它与完全数密切相关。 任务:从文件中输入P1000 < P < 3100000), 计算2^P-1的位数和最后500位数字(用十进制高精度数表示)

文件中只包含一个整数P1000 < P < 3100000

第一行:十进制高精度数2^P-1的位数。 第2-11行:十进制高精度数2^P-1的最后500位数字。(每行输出50位,共输出10行,不足500位时高位补0) 不必验证2^P-1P是否为素数。

1279

386 00000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000 00000000000000104079321946643990819252403273640855 38615262247266704805319112350403608059673360298012 23944173232418484242161395428100779138356624832346 49081399066056773207629241295093892203457731833496 61583550472959420547689811211693677147548478866962 50138443826029173234888531116082853841658502825560 46662248318909188018470682222031405210266984354887 32958028878050869736186900714720710555703168729087

0

 

NOIP_2003.PJ4

2017-03-18 12:03:24

1

64

N

1

8

0

1053

NOIP_2004.PJ1:不高兴的津津

津津上初中了。妈妈认为津津应该更加用功学习,所以津津除了上学之外,还要参加妈妈为她报名的各科复习班。另外每周妈妈还会送她去学习朗诵、舞蹈和钢琴。但是津津如果一天上课超过八个小时就会不高兴,而且上得越久就会越不高兴。假设津津不会因为其它事不高兴,并且她的不高兴不会持续到第二天。请你帮忙检查一下津津下周的日程安排,看看下周她会不会不高兴;如果会的话,哪天最不高兴。

输入文件unhappy.in包括七行数据,分别表示周一到周日的日程安排。每行包括两个小于10的非负整数,用空格隔开,分别表示津津在学校上课的时间和妈妈安排她上课的时间。

输出文件unhappy.out包括一行,这一行只包含一个数字。 如果不会不高兴则输出0, 如果会则输出最不高兴的是周几 (用1, 2, 3, 4, 5, 6, 7分别表示周一,周二,周三,周四,周五,周六,周日)。 如果有两天或两天以上不高兴的程度相当,则输出时间最靠前的一天。

5 3 6 2 7 2 5 3 5 4 0 4 0 6

3

0

 

NOIP_2004.PJ1

2017-03-18 12:03:24

1

64

N

8

9

0

1054

NOIP_2004.PJ2:花生采摘

鲁宾逊先生有一只宠物猴,名叫多多。这天,他们两个正沿着乡间小路散步,突然发现路边的告示牌上贴着一张小小的纸条:欢迎免费品尝我种的花生!——熊字。 鲁宾逊先生和多多都很开心,因为花生正是他们的最爱。在告示牌背后,路边真的有一块花生田,花生植株整齐地排列成矩形网格(如图1)。有经验的多多一眼就能看出,每棵花生植株下的花生有多少。为了训练多多的算术,鲁宾逊先生说:你先找出花生最多的植株,去采摘它的花生;然后再找出剩下的植株里花生最多的,去采摘它的花生;依此类推,不过你一定要在我限定的时间内回到路边。我们假定多多在每个单位时间内,可以做下列四件事情中的一件: (1) 从路边跳到最靠近路边(即第一行)的某棵花生植株; (2) 从一棵植株跳到前后左右与之相邻的另一棵植株; (3) 采摘一棵植株下的花生; (4) 从最靠近路边(即第一行)的某棵花生植株跳回路边。 现在给定一块花生田的大小和花生的分布,请问在限定时间内,多多最多可以采到多少个花生?注意可能只有部分植株下面长有花生,假设这些植株下的花生个数各不相同。 例如在图2所示的花生田里,只有位于(2, 5), (3, 7), (4, 2), (5, 4)的植株下长有花生,个数分别为13, 7, 15, 9。沿着图示的路线,多多在21个单位时间内,最多可以采到37个花生。

输入文件peanuts.in 第一行包括三个整数,M, NK,用空格隔开; 表示花生田的大小为M * N1 <= M, N <= 20), 多多采花生的限定时间为K0 <= K <= 1000)个单位时间。 接下来的M行,每行包括N个非负整数,也用空格隔开; 第i + 1行的第j个整数Pij0 <= Pij <= 500)表示花生田里植株(i, j)下花生的数目,0表示该植株下没有花生。

输出文件peanuts.out包括一行,这一行只包含一个整数,即在限定时间内,多多最多可以采到花生的个数。

【样例输入1 6 7 21 0 0 0 0 0 0 0 0 0 0 0 13 0 0 0 0 0 0 0 0 7 0 15 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0 0 0 0 0 【样例输入2 6 7 20 0 0 0 0 0 0 0 0 0 0 0 13 0 0 0 0 0 0 0 0 7 0 15 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0 0 0 0 0

【样例输出1 37 【样例输出2 28

0

 

NOIP_2004.PJ2

2017-03-18 12:03:24

1

64

N

2

5

0

1055

NOIP_2004.PJ3:FBI

我们可以把由“0”“1”组成的字符串分为三类: 全“0”串称为B串,全“1”串称为I串,既含“0”又含“1”的串则称为F串。 FBI树是一种二叉树[1],它的结点类型也包括F结点,B结点和I结点三种。 由一个长度为2N“01”S可以构造出一棵FBIT,递归的构造方法如下: (1) T的根结点为R,其类型与串S的类型相同; (2) 若串S的长度大于1,将串S从中间分开,分为等长的左右子串S1S2; 由左子串S1构造R的左子树T1,由右子串S2构造R的右子树T2。 现在给定一个长度为2N“01”串,请用上述构造方法构造出一棵FBI树,并输出它的后序遍历[2]序列。

输入文件fbi.in的第一行是一个整数N0 <= N <= 10),第二行是一个长度为2N“01”串。

输出文件fbi.out包括一行,这一行只包含一个字符串,即FBI树的后序遍历序列。

3 10001011

IBFBBBFIBFIIIFF

0

【数据规模】 对于40%的数据,N <= 2; 对于全部的数据,N <= 10 -------------------------------------------------------------------------------- [1] 二叉树:二叉树是结点的有限集合,这个集合或为空集,或由一个根结点和两棵不相交的二叉树组成。 这两棵不相交的二叉树分别称为这个根结点的左子树和右子树。 [2] 后序遍历:后序遍历是深度优先遍历二叉树的一种方法。 它的递归定义是:先后序遍历左子树,再后序遍历右子树,最后访问根。

NOIP_2004.PJ3

2017-03-18 12:03:24

1

64

N

3

4

0

1056

NOIP_2004.PJ4:火星人

人类终于登上了火星的土地并且见到了神秘的火星人。人类和火星人都无法理解对方的语言,但是我们的科学家发明了一种用数字交流的方法。这种交流方法是这样的,首先,火星人把一个非常大的数字告诉人类科学家,科学家破解这个数字的含义后,再把一个很小的数字加到这个大数上面,把结果告诉火星人,作为人类的回答。 火星人用一种非常简单的方式来表示数字——掰手指。火星人只有一只手,但这只手上有成千上万的手指,这些手指排成一列,分别编号为123……。火星人的任意两根手指都能随意交换位置,他们就是通过这方法计数的。 一个火星人用一个人类的手演示了如何用手指计数。如果把五根手指——拇指、食指、中指、无名指和小指分别编号为12345,当它们按正常顺序排列时,形成了5位数12345,当你交换无名指和小指的位置时,会形成5位数12354,当你把五个手指的顺序完全颠倒时,会形成54321,在所有能够形成的1205位数中,12345最小,它表示112354第二小,它表示254321最大,它表示120。下表展示了只有3根手指时能够形成的63位数和它们代表的数字: 三进制数 123 132 213 231 312 321 代表的数字 1 2 3 4 5 6 现在你有幸成为了第一个和火星人交流的地球人。一个火星人会让你看他的手指,科学家会告诉你要加上去的很小的数。你的任务是,把火星人用手指表示的数与科学家告诉你的数相加,并根据相加的结果改变火星人手指的排列顺序。输入数据保证这个结果不会超出火星人手指能表示的范围。

输入文件martian.in包括三行,第一行有一个正整数N,表示火星人手指的数目(1 <= N <= 10000)。第二行是一个正整数M,表示要加上去的小整数(1 <= M <= 100)。下一行是1NN个整数的一个排列,用空格隔开,表示火星人手指的排列顺序。

输出文件martian.out只有一行,这一行含有N个整数,表示改变后的火星人手指的排列顺序。每两个相邻的数中间用一个空格分开,不能有多余的空格。

5 3 1 2 3 4 5

1 2 4 5 3

0

【数据规模】 对于30%的数据,N<=15; 对于60%的数据,N<=50; 对于全部的数据,N<=10000

NOIP_2004.PJ4

2017-03-18 12:03:24

1

64

N

4

5

0

1057

NOIP_2005.PJ1:陶陶摘苹果

陶陶家的院子里有一棵苹果树,每到秋天树上就会结出10个苹果。苹果成熟的时候,陶陶就会跑去摘苹果。陶陶有个30厘米高的板凳,当她不能直接用手摘到苹果的时候,就会踩到板凳上再试试。 现在已知10个苹果到地面的高度,以及陶陶把手伸直的时候能够达到的最大高度,请帮陶陶算一下她能够摘到的苹果的数目。假设她碰到苹果,苹果就会掉下来。

输入文件apple.in包括两行数据。 第一行包含10100200之间(包括100200)的整数(以厘米为单位) 分别表示10个苹果到地面的高度,两个相邻的整数之间用一个空格隔开。 第二行只包括一个100120之间(包含100120)的整数(以厘米为单位),表示陶陶把手伸直的时候能够达到的最大高度。

输出文件apple.out包括一行, 这一行只包含一个整数,表示陶陶能够摘到的苹果的数目。

100 200 150 140 129 134 167 198 200 111 110

5

0

 

NOIP_2005.PJ1

2017-03-18 12:03:24

1

64

N

5

8

0

1058

NOIP_2005.PJ2:校门外的树

某校大门外长度为L的马路上有一排树,每两棵相邻的树之间的间隔都是1米。我们可以把马路看成一个数轴,马路的一端在数轴0的位置,另一端在L的位置;数轴上的每个整数点,即012……L,都种有一棵树。 由于马路上有一些区域要用来建地铁。这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数,区域之间可能有重合的部分。现在要把这些区域中的树(包括区域端点处的两棵树)移走。你的任务是计算将这些树都移走后,马路上还有多少棵树。

输入文件tree.in的第一行有两个整数L1 <= L <= 10000)和 M1 <= M <= 100), L代表马路的长度,M代表区域的数目,LM之间用一个空格隔开。 接下来的M行每行包含两个不同的整数,用一个空格隔开,表示一个区域的起始点和终止点的坐标。

输出文件tree.out包括一行, 这一行只包含一个整数,表示马路上剩余的树的数目。

500 3 150 300 100 200 470 471

298

0

【数据规模】 对于20%的数据,区域之间没有重合的部分; 对于其它的数据,区域之间有重合的情况。

NOIP_2005.PJ2

2017-03-18 12:03:24

1

64

N

24

35

0

1059

NOIP_2005.PJ3:采药

辰辰是个天资聪颖的孩子,他的梦想是成为世界上最伟大的医师。为此,他想拜附近最有威望的医师为师。医师为了判断他的资质,给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说:孩子,这个山洞里有一些不同的草药,采每一株都需要一些时间,每一株也有它自身的价值。我会给你一段时间,在这段时间里,你可以采到一些草药。如果你是一个聪明的孩子,你应该可以让采到的草药的总价值最大。如果你是辰辰,你能完成这个任务吗?

输入文件medic.in的第一行有两个整数T1 <= T <= 1000)和M1 <= M <= 100),用一个空格隔开, T代表总共能够用来采药的时间,M代表山洞里的草药的数目。 接下来的M行每行包括两个在1100之间(包括1100)的整数, 分别表示采摘某株草药的时间和这株草药的价值。

输出文件medic.out包括一行, 这一行只包含一个整数,表示在规定的时间内,可以采到的草药的最大总价值。

70 3 71 100 69 1 1 2

3

0

【数据规模】 对于30%的数据,M <= 10; 对于全部的数据,M <= 100

NOIP_2005.PJ3

2017-03-18 12:03:24

1

64

N

3

5

0

1060

【高精度】NOIP_2005.PJ4:循环

乐乐是一个聪明而又勤奋好学的孩子。他总喜欢探求事物的规律。一天,他突然对数的正整数次幂产生了兴趣。 众所周知,2的正整数次幂最后一位数总是不断的在重复24862486……我们说2的正整数次幂最后一位的循环长度是4(实际上4的倍数都可以说是循环长度,但我们只考虑最小的循环长度)。类似的,其余的数字的正整数次幂最后一位数也有类似的循环现象: 2 2486 4 3 3971 4 4 46 2 5 5 1 6 6 1 7 7931 4 8 8426 4 9 91 2 这时乐乐的问题就出来了:是不是只有最后一位才有这样的循环呢?对于一个整数n的正整数次幂来说,它的后k位是否会发生循环?如果循环的话,循环长度是多少呢? 注意: 1. 如果n的某个正整数次幂的位数不足k,那么不足的高位看做是0 2. 如果循环长度是L,那么说明对于任意的正整数ana次幂和a + L次幂的最后k位都相同。

输入文件circle.in只有一行,包含两个整数n1 <= n < 10100)和k1 <= k <= 100),nk之间用一个空格隔开, 表示要求n的正整数次幂的最后k位的循环长度。

输出文件circle.out包括一行,这一行只包含一个整数, 表示循环长度。如果循环不存在,输出-1

32 2

4

0

【数据规模】 对于30%的数据,k <= 4; 对于全部的数据,k <= 100

NOIP_2005.PJ4

2017-03-18 12:03:24

1

64

N

2

3

0

1061

NOIP_2006.PJ1:明明的随机数

明明想在学校中请一些同学一起做一项问卷调查,为了实验的客观性,他先用计算机生成了N11000之间的随机整数(N≤100),对于其中重复的数字,只保留一个,把其余相同的数去掉,不同的数对应着不同的学生的学号。然后再把这些数从小到大排序,按照排好的顺序去找同学做调查。请你协助明明完成去重排序的工作。

输入文件random.in 2: 1行为1个正整数,表示所生成的随机数的个数N。 第2行有N个用空格隔开的正整数,为所产生的随机数。

输出文件random.out 也是2: 1行为1个正整数M,表示不相同的随机数的个数。 第2行为M个用空格隔开的正整数,为从小到大排好序的不相同的随机数。

10 20 40 32 67 40 20 89 300 400 15

8 15 20 32 40 67 89 300 400

0

 

NOIP_2006.PJ1

2017-03-18 12:03:24

1

64

N

16

52

0

1062

NOIP_2006.PJ2:开心的金明

金明今天很开心,家里购置的新房就要领钥匙了,新房里有一间他自己专用的很宽敞的房间。更让他高兴的是,妈妈昨天对他说:你的房间需要购买哪些物品,怎么布置,你说了算,只要不超过N元钱就行。今天一早金明就开始做预算,但是他想买的东西太多了,肯定会超过妈妈限定的N元。于是,他把每件物品规定了一个重要度,分为5等:用整数1~5表示,第5等最重要。他还从因特网上查到了每件物品的价格(都是整数元)。他希望在不超过N元(可以等于N元)的前提下,使每件物品的价格与重要度的乘积的总和最大。 设第j件物品的价格为v[j],重要度为w[j],共选中了k件物品,编号依次为j1j2……jk,则所求的总和为: v[j1]*w[j1]+v[j2]*w[j2]+ …+v[jk]*w[jk]。(其中*为乘号) 请你帮助金明设计一个满足要求的购物单。

输入文件happy.in 的第1行,为两个正整数,用一个空格隔开: N m (其中N<30000)表示总钱数,m<25)为希望购买物品的个数。) 从第2行到第m+1行,第j行给出了编号为j-1的物品的基本数据,每行有2个非负整数 v p (其中v表示该物品的价格(v<=10000)p表示该物品的重要度(1~5)

输出文件happy.out只有一个正整数,为不超过总钱数的物品的价格与重要度乘积的总和的最大值(<100000000)。

1000 5 800 2 400 5 300 5 400 3 200 2

3900

0

 

NOIP_2006.PJ2

2017-03-18 12:03:24

1

64

N

3

4

0

1063

NOIP_2006.PJ3:Jam的计数法

Jam是个喜欢标新立异的科学怪人。他不使用阿拉伯数字计数,而是使用小写英文字母计数,他觉得这样做,会使世界更加丰富多彩。在他的计数法中,每个数字的位数都是相同的(使用相同个数的字母),英文字母按原先的顺序,排在前面的字母小于排在它后面的字母。我们把这样的数字称为Jam数字。在Jam数字中,每个字母互不相同,而且从左到右是严格递增的。每次,Jam还指定使用字母的范围,例如,从210,表示只能使用{b,c,d,e,f,g,h,i,j}这些字母。如果再规定位数为5,那么,紧接在Jam数字“bdfij”之后的数字应该是“bdghi”。 (如果我们用UV依次表示Jam数字“bdfij”“bdghi”,则U<V< span>,且不存在Jam数字P,使U<P<V< span>)。 你的任务是:对于从文件读入的一个Jam数字,按顺序输出紧接在后面的5Jam数字,如果后面没有那么多Jam数字,那么有几个就输出几个。

输入文件counting.in 2行, 第1行为3个正整数,用一个空格隔开: s t w (其中s为所使用的最小的字母的序号,t为所使用的最大的字母的序号。w为数字的位数,这3个数满足:1≤s<T< span>≤26, 2≤w≤t-s ) 第2行为具有w个小写字母的字符串,为一个符合要求的Jam数字。 所给的数据都是正确的,不必验证。

输出文件counting.out 最多为5行, 为紧接在输入的Jam数字后面的5Jam数字,如果后面没有那么多Jam数字,那么有几个就输出几个。 每行只输出一个Jam数字,是由w个小写字母组成的字符串,不要有多余的空格。

2 10 5 bdfij

bdghi bdghj bdgij bdhij befgh

0

 

NOIP_2006.PJ3

2017-03-18 12:03:24

1

64

N

0

2

0

1064

NOIP_2006.PJ4:数列

给定一个正整数k(3≤k≤15),把所有k的方幂及所有有限个互不相等的k的方幂之和构成一个递增的序列, 例如,当k=3时,这个序列是: 1349101213(该序列实际上就是:3^03^13^0+3^13^23^0+3^23^1+3^23^0+3^1+3^2) 请你求出这个序列的第N项的值(用10进制数表示)。 例如,对于k=3N=100,正确答案应该是981

输入文件sequence.in 只有1行,为2个正整数,用一个空格隔开: k N kN的含义与上述的问题描述一致,且3≤k≤1510≤N≤1000)。

输出文件sequence.out 为计算结果,是一个正整数(在所有的测试数据中,结果均不超过2.1*10^9)。 (整数前不要有空格和其他符号)。

3 100

981

0

 

NOIP_2006.PJ4

2017-03-18 12:03:24

1

64

N

1

2

0

1065

NOIP_2007.PJ1:奖学金

某小学最近得到了一笔赞助,打算拿出其中一部分为学习成绩优秀的前5名学生发奖学金。期末,每个学生都有3门课的成绩:语文、数学、英语。先按总分从高到低排序,如果两个同学总分相同,再按语文成绩从高到低排序,如果两个同学总分和语文成绩都相同,那么规定学号小的同学排在前面,这样,每个学生的排序是唯一确定的。 任务:先根据输入的3门课的成绩计算总分,然后按上述规则排序,最后按排名顺序输出前五名名学生的学号和总分。注意,在前5名同学中,每个人的奖学金都不相同,因此,你必须严格按上述规则排序。例如,在某个正确答案中,如果前两行的输出数据(每行输出两个数:学号、总分) : 7 279 5 279 这两行数据的含义是:总分最高的两个同学的学号依次是7号、5号。这两名同学的总分都是 279 (总分等于输入的语文、数学、英语三科成绩之和) ,但学号为7的学生语文成绩更高一些。如果你的前两名的输出数据是: 5 279 7 279 则按输出错误处理,不能得分。

输入文件scholar.in包含n+1: 1行为一个正整数n,表示该校参加评选的学生人数。 第2n+1行,每行有3个用空格隔开的数字,每个数字都在O100之间 第1行的3个数字依次表示学号为j-1的学生的语文、数学、英语的成绩。 每个学生的学号按照输入顺序编号为l--n (恰好是输入数据的行号减1)。 所给的数据都是正确的,不必检验。

输出文件scholar.out共有5行, 每行是两个用空格隔开的正整数,依次表示前5名学生的学号和总分。

【输入样例1 6 90 67 80 87 66 91 78 89 91 88 99 77 67 89 64 78 89 98 【输入样例2 8 80 89 89 88 98 78 90 67 80 87 66 91 78 89 91 88 99 77 67 89 64 78 89 98

【输出样例1 6 265 4 264 3 258 2 244 1 237 【输出样例2 8 265 2 264 6 264 1 258 5 258

0

【限制】 50%的数据满足:各学生的总成绩各不相同 100%的数据满足: 6<=n<=300

NOIP_2007.PJ1

2017-03-18 12:03:24

1

64

N

1

4

0

1066

【贪心】NOIP_2007.PJ2:纪念品分组

元旦快到了,校学生会让乐乐负责新年晚会的纪念品发放工作。为使得参加晚会的同学所获得 的纪念品价值相对均衡,他要把购来的纪念品根据价格进行分组,但每组最多只能包括两件纪念品, 并且每组纪念品的价格之和不能超过一个给定的整数。为了保证在尽量短的时间内发完所有纪念品,乐乐希望分组的数目最少。 你的任务是写一个程序,找出所有分组方案中分组数最少的一种,输出最少的分组数目。

输入文件group.in包含n+2: 1行包括一个整数w,为每组纪念品价格之和的上限值。 第2行为一个整数n,表示购来的纪念品的总件数G 3-n+2行每行包含一个正整数Pi (5 <= Pi <= w3)w表示所对应纪念品的价格。

输出文件group.out仅一行,包含一个整数, ep最少的分组数目数

100 9 90 20 20 30 50 60 70 80 90

6

0

【限制】 50%的数据满足 : 1 <= n <= 15 100%的数据满足: 1 <= n <= 30000 80 <= W <= 200

NOIP_2007.PJ2

2017-03-18 12:03:24

1

64

N

2

4

0

1067

NOIP_2007.PJ3:守望者的逃离

恶魔猎手尤迫安野心勃勃.他背叛了暗夜精灵,率深藏在海底的那加企图叛变:守望者在与尤迪安的交锋中遭遇了围杀.被困在一个荒芜的大岛上。为了杀死守望者,尤迪安开始对这个荒岛施咒,这座岛很快就会沉下去,到那时,岛上的所有人都会遇难:守望者的跑步速度,为17m/s,以这样的速度是无法逃离荒岛的。庆幸的是守望者拥有闪烁法术,可在1s内移动60m,不过每次使用闪烁法术都会消耗魔法值10点。守望者的魔法值恢复的速度为4/s,只有处在原地休息状态时才能恢复。 现在已知守望者的魔法初值M,他所在的初始位置与岛的出口之间的距离S,岛沉没的时间T。你的任务是写一个程序帮助守望者计算如何在最短的时间内逃离荒岛,若不能逃出,则输出守望者在剩下的时间内能走的最远距离。注意:守望者跑步、闪烁或休息活动均以秒(s)为单位。且每次活动的持续时间为整数秒。距离的单位为米(m)

输入文件escape.in仅一行,包括空格隔开的三个非负整数MST

输出文件escape.out包含两行: 1行为字符串"Yes""No" (区分大小写),即守望者是否能逃离荒岛。 第2行包含一个整数,第一行为"Yes" (区分大小写)时表示守望着逃离荒岛的最短时间 第一行为"No" (区分大小写) 时表示守望者能走的最远距离。

【输入样例1 39 200 4 【输入样例2 36 255 10

【输出样例1 No 197 【输出样例2 Yes 6

0

【限制】 30%的数据满足: 1 <= T<= 10 1 <=S<= 100 50%的数据满足: 1 <= T <= 1000 1 <= S <= 10000 100%的数据满足: 1 <= T <= 300000 0 <= M<=1000 1 <=S <= 10^8

NOIP_2007.PJ3

2017-03-28 15:36:37

1

64

N

0

3

0

1068

NOIP_2007.PJ4:Hanoi双塔问题

给定A,B,C三根足够长的细柱,在A柱上放有2n个中间有空的圆盘,共有n个不同的尺寸,每个尺寸都有两个相同的圆盘,注意这两个圆盘是不加区分的(下图为n=3的情形)。现要将 这些国盘移到C柱上,在移动过程中可放在B柱上暂存。要求: (1)每次只能移动一个圆盘; (2) ABC三根细柱上的圆盘都要保持上小下大的顺序; 任务:An2n个圆盘完成上述任务所需的最少移动次数,对于输入的n,输出An

输入文件hanoi.in为一个正整数n,表示在A柱上放有2n个圆盘。

输出文件hanoi.out仅一行,包含一个正整数,为完成上述任务所需的最少移动次数An

【输入样例1 1 【输入样例2 2

【输出样例1 2 【输出样例2 6

0

【限制】 对于50%的数据, 1<=n<=25 对于100% 数据, 1<=n<=200 【提示】 设法建立AnAn-1的递推关系式。

NOIP_2007.PJ4

2017-03-18 12:03:24

1

64

N

1

3

0

1069

USACO教程:Graph Theory图论知识

Graph Theory 图论知识   译 by Lucky Crazy 何为图? 正式地说,图G是由: 所有结点的集合 V 所有边的集合 E 构成的,简写成G(VE)。 我们可以把结点假设成一个地点,而结点集合就是一个所有地点的集合。同样,边可以被假设成连接两个地点的一条;那么边的集合就可以认为是所有这样的的集合。 表示方法: 图通常用如下方法表示;结点是点或者圈,而边是直线或者曲线。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph1.gif> 在上图中,结点 V = {1, 2, 3, 4, 5, 6} ,边E = {(1, 3), (1, 6), (2, 5), (3, 4), (3, 6)}. 每一个结点都是集合V中的一个数字,每条边都是集合E中的成员,注意并不是每个节点都有边与其他结点相连,这样没有边与其他结点相连的结点被称作孤立结点。 有时,边会与一些数值关联,类似表示边的长度或花费。我们把这些数字称作边的权,这样边有权的图被称为边权图。类似的,我们还定义了点权图,即每个结点都有一个权。 图论的几个例子 奶牛的电信 (USACO 锦标赛 1996) 农夫约翰的奶牛们喜欢通过电邮保持联系,于是她们建立了一个奶牛电脑网络,以便互相交流。这些机器用如下的方式发送电邮:如果存在一个由c台电脑组成的序列a1,a2,...,a(c),且a1a2相连,a2a3相连,等等,那么电脑a1a(c)就可以互发电邮。很不幸,有时候奶牛会不小心踩到电脑上,农夫约翰的车也可能碾过电脑,这台倒霉的电脑就会坏掉。这意味着这台电脑不能再发送电邮了,于是与这台电脑相关的连接也就不可用了。有两头奶牛就想:如果我们两个不能互发电邮,至少需要坏掉多少台电脑呢?请编写一个程序为她们计算这个最小值和与之对应的坏掉的电脑集合。 图: 每个结点表示一台电脑,而边就相对应的成了连接各台电脑的缆线。 骑马修栅栏 农民John每年有很多栅栏要修理。他总是骑着马穿过每一个栅栏并修复它破损的地方。John是一个与其他农民一样懒的人。他讨厌骑马,因此从来不两次经过一个一个栅栏。你必须编一个程序,读入栅栏网络的描述,并计算出一条修栅栏的路径,使每个栅栏都恰好被经过一次。John能从任何一个顶点(即两个栅栏的交点)开始骑马,在任意一个顶点结束。每一个栅栏连接两个顶点,顶点用1500标号(虽然有的农场并没有500个顶点)。一个顶点上可连接任意多(>=1)个栅栏。所有栅栏都是连通的(也就是你可以从任意一个栅栏到达另外的所有栅栏)。你的程序必须输出骑马的路径(用路上依次经过的顶点号码表示)。我们如果把输出的路径看成是一个500进制的数,那么当存在多组解的情况下,输出500进制表示法中最小的一个 (也就是输出第一个数较小的,如果还有多组解,输出第二个数较小的,等等)。输入数据保证至少有一个解。 图: 农民John从一个栅栏交叉点开始,经过所有栅栏一次。因而,图的结点就是栅栏交叉点,边就是栅栏。 骑士覆盖问题 在一个 n x n 的棋盘中摆放尽量少的骑士,使得棋盘的每一格都会被至少一个骑士攻击到。但骑士无法攻击到它自己站的位置. : 这里的图较为特殊,棋盘的每一格都是一个结点,如果骑士能从这一格跳到另一格,这就说在这两个格相对应的结点之间有一条边。 穿越栅栏 [1999 USACO 春季公开赛] 农夫John在外面的田野上搭建了一个巨大的用栅栏围成的迷宫。幸运的是,他在迷宫的边界上留出了两段栅栏作为迷宫的出口。更幸运的是,他所建造的迷宫是一个完美的迷宫:即你能从迷宫中的任意一点找到一条走出迷宫的路。 给定迷宫的宽W(1<=W<=38)及长H(1<=H<=100) 2*H+1行,每行2*W+1的字符以下面给出的格式表示一个迷宫。然后计算从迷宫中最糟糕的那一个点走出迷宫所需的步数。(即使从这一点以最优的方式走向最靠近的出口,它仍然需要最多的步数)当然了,牛们只会水平或垂直地在XY轴上移动,他们从来不走对角线。每移动到一个新的方格算作一步(包括移出迷宫的那一步) 这是一个W=5,H=3的迷宫: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph10.gif > 如上图的例子,栅栏的柱子只出现在奇数行或奇数列。每个迷宫只有两个出口。 图: 如上图,图的每一个位置都是一个结点,如果两个相邻的位置之间没有被栅栏分开,则说在这两个位置相对应的结点之间有一条边。 用语: 我们再看刚才的图: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph2.gif > 如果有一条边起点与终点都是同一个结点,我们就称它为环边,表示为(v, v),上图中没有环边。 简单图是指一张没有环边且边在边集E中不重复出现的图。与简单图相对的是复杂图。在我们的讨论中不涉及复杂图,所有的图都是简单图。 边 (u,v) 连接了结点u和结点v 。例如,边 (1,3) 连接了结点13。结点的度是指连接该结点所有边的个数。例如,结点3的度数是3,结点4的度数是1。 通常,如果结点uv被用一条边连接,我们就说结点uv相连,例如,上图结点25相连。 稀疏图 的定义是图的边的总数小于可能边数((N x (N-1))/2)N为结点数),而密集图的定义相反。例如,上图就是一张稀疏图。 有向图: 在以上内容中我们介绍的图都为无向图,即每一条边都是双向的,如果存在一条边(1,3),则我们可以从结点1到达结点3,也可以从结点3到达结点1,换句话说,如果存在边(1,3)就必定存在边(3,1)。 但有时,图也必须被定于成有向图,即每条边都有一个方向,我们只能单向地根据边的方向遍历图。这样的边又称为弧。弧用带箭号的直线或弧线表示。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph3.gif > 有向图结点的出度就是指从该结点出发的弧的个数,相反,结点的入度就是指在该结点结束的弧的个数。例如,上图结点6的入度为2,出度为1。 路径: 如果我们说结点u到结点x有路径,就是指存在一个结点的序列 (v 0, v 1, ..., v k) v 0 = u v k = x , 以及(v 0, v 1) 是边集中的一条边,同样,(v 1, v 2), (v 2, v 3)……也是。 例如,上面的无向图, (4, 3, 1, 6) 就是从46的一条路径。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph4.gif > 这条路径包含了边(4,3)(3,1)(1,6)。 如果结点xv有一条路径,则我们从结点x开始通过边必定能访问到结点v。 在一条路径序列中,如果所经过的结点都只在序列中出现一次,我们就称它为简单路径。 环的定义是一条起始结点与中止结点为同一结点的路径,如果一个环除了起始结点(中止结点)以外的所有结点都只在环中出现一次,那么这种环被称为简单环。 以上定义同样适用于有向图。 图的表示法 选择一个好的方法来表示一张图是十分重要的,因为不同的图的表示方法有着不同的时间及空间需求。 通常,结点被用数字编号来表示,我们可以通过它们的编号数字来对他们进行索引。 这样,似乎所有问题都集中在如何表示边上了。 边集 边集表示法似乎是最明显的表示法,他将所有边列成一张表,用结点来表示边。 该表示法容易编写,容易调试且所需空间小。但是,它需要花费相当大的代价用于确定一条边是否存在,即确定两个结点是否相连。利用边集添加新边是很快的,但删除旧边就很麻烦了,尤其是当需要删除的边在边集中的所在位置不确定时。 对于带权图,该表示法也只需要在边集中添加一个元素,用于记录边权。同样,该表示法也适用于有向图和稀疏图。 例: 一张无向无权图可以表示成边集如下: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph11.gif > 邻接矩阵 邻接矩阵式表示图的另一种方法,邻接矩阵是一个N乘以N的数组(N为结点数)。 如果边集E中存在边(i,j),则对应数组的(i,j)元素的值为一。相反,如果数组元素的值为零,就意味着图中结点ij之间没有边。无向图的邻接矩阵总是关于左上右下对角线对称。 该表示法容易编写。但他对空间的需求和浪费较大,尤其是对于较大的稀疏图,调试起来也比较麻烦,并且寻找与某一结点相连的结点也很慢。不过该表示法在判断两结点是否相连,以及在添加、删除结点方面速度都是极快的。 对于带权图,数组的(i,j)元素的值被表示为边(i,j)的权。对于无权复杂图来说,数组的(i,j)元素的值可以用于表示结点(i,j)之间边的个数。而对于有权复杂图来说,邻接矩阵很难将其表示清楚。 例: 下面是用邻接矩阵表示一幅无权图的例子: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph12.gif > 邻接表 第三种表示图的方法是用一个列表列出所有与现结点之间有边存在的结点名称。该方法可以用一个长度为N的数组来实现(N为结点个数),数组的每一个元素都是一个链表表头。数组的第i元素所连接的链表连接了所有与结点i之间有边的结点名称。 该表示方法较难编写,特别是对于复杂图,两结点之间边的个数不受限制的时候,链表可能要做成环,或者要动态分配内存。邻接表的调试也同样十分麻烦,特别是使用了环形链表后。但是,这种表示法所需求的空间与边集相同,寻找某结点的相邻结点也十分容易,然而,如果需要判断两结点是否相邻,就需要遍历该结点的所有相邻结点以证明相邻性,这浪费了不少时间。添加边十分容易,但删除边就十分困难了。 将该表示法用于带权图,就需要在链表的每一节上添加一个元素用于储存该节表示的两结点之间的权。有向图与复杂图同样可以用邻接表表示。对于有向图,我们只需存储单向的相邻即可。 例: 邻接表表示无向图如下: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph13.gif > 表示法的选择: 对于某些图来说,我们并不需要考虑所有结点之间的关系,例如上面的骑士覆盖和穿越栅栏两题,我们只需考虑与某结点相邻结点之间的关系,确定相连,我们就不用考虑存储两个不相邻结点之间的信息。当然,这些信息来自于题目本身的暗示。 如果你发现一种表示方法可以在规定空间与时间范围内实现你的算法解决问题,并且可以使你的程序变得简洁、容易调试,那它通常就是对的。记住,编写与调试的简单是最重要的,我们不需要为一些毫无意义的加快程序速度,减少使用空间来浪费编写与调试的时间。 我们还要通过题目给我们的信息,确定我们要对图进行哪些操作,权衡后来决定表示方法。下面的表示我们为您提供的选择依据(N为结点数,M为边数,d max 为图中度的最大值): <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph14.gif > 图的连通性 如果一个图的任意两个结点之间都有一条以上的路径相连,我们就称该图为连通图。例如下图就不是连通图,因为结点2到结点4之间没有路径相通。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph1.gif > 但是如果我们在该图的结点56之间添加一条边,该图就成为了连通图。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph2.gif > 子图: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph1.gif > 如果G = (V, E)成立,且有集合V'V集合的子集,集合E'是集合E的子集,那么我们就说 图 G' = (V', E') 是图 G = (V, E) 的子图。 同时,在边集合E'中出现的边必须是连接结点集合V'中出现的两结点的边。我们考虑下图,它是例图的一个子图,其中V'= {1, 2, 3, 4,}E' = {(1, 3), (1, 4)}。但是如果我们在边集E'中添加一条边(1, 6)E'仍然是E的子集,但由于在V'中没有出现结点6,边(1, 6)就不可能在子图G' = (V', E')中出现。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph5.gif > 连通子图,如同它的名称一样,是一张图的子图,且该子图就有连通性,如下图,{1, 3, 4, 6}{2, 5}{1, 3, 4} {13}都是该图的连通子图(原文中在此仅标注了结点,我们尚且将边默认为所有这些结点之间的边——译者)。同时,我们还定义了极大连通子图,它的定义可以理解为将连通子图扩展的尽量大,在例图中仅有两个极大连通子图:{1, 3, 4, 6}{2, 5}。非连通图的极大连通子图被称为连通分量;有向图中的连通图叫做强连通图;非强连通图中的极大连通子图被称为强连通分量。一个连通图的生成树是该图的极小连通子图,在有N个结点的情况下,生成树仅有N-1条边。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph1.gif > 特殊的图: 连通且无环的无向图被称作树。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph6.gif > 许多树都是层次化的。通常,树都有一个最顶上的结点,被称作根结点;相反,最底下的结点们被称作叶结点。除了根结点以外,所有结点都仅有一个父结点,即与它相连的那个上一层结点;除了叶结点以外,所有结点都至少有一个子女结点,即与它相连的所有下一层结点。同样,类推地,还有祖先结点、后代结点。经过这样的定义后,树的样式就可以构划得像一棵倒过来生长的树了(如上图)。 不连通且无环的无向图被称为森林(如下图)。他也可以理解为是有许多树构成的图。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph7.gif > 有向无环图(Directed Acyclic Graph)被称为DAG,是他的英文缩写。 一个图的任意结点与其它所有结点有边相连的图被称为完全图。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph8.gif > 如果一个图的所有结点可以被分为两个组,同组之间的任意结点都没有边相连,即所有边连接的都是不同组的两个结点,这样的图被称为二分图。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph9.gif >

Graph Theory What's a Graph? Formally, a graph is the following: a collection of vertices V, and a collection of edges E consisting of pairs of vertices. Think of vertices as ``locations''. The set of vertices is the set of all the possible locations. In this analogy, edges represent paths between pairs of those locations; the set E contains all the paths between the locations. Representation The graph is normally represented using that analogy. Vertices are points or circles; edges are lines between them. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph1.gif > In this example graph, V = {1, 2, 3, 4, 5, 6} and E = {(1,3), (1,6), (2,5), (3,4), (3,6)}. Each vertex is a member of the set V. A vertex is sometimes called a node. Each edge is a member of the set E. Note that some vertices might not be the end point of any edge. Such vertices are termed `isolated'. Sometimes, numerical values are associated with edges, specifying lengths or costs; such graphs are called edge-weighted graphs (or weighted graphs). The value associated with an edge is called the weight of the edge. A similar definition holds for node-weighted graphs, Examples of Graphs Telecowmunication (USACO Championship 1996) Given a set of computers and a set of wires running between pairs of computers, what is the minimum number of machines whose crash causes two given machines to be unable to communicate? (The two given machines will not crash.) Graph: The vertices of the graph are the computers. The edges are the wires between the computers. Sample Problem: Riding The Fences Farmer John owns a large number of fences, which he must periodically check for integrity. He keeps track of his fences by maintaining a list of points at which fences intersect. He records the name of the point and the one or two fence names that touch that point. Every fence has two end points, each at some intersection point, although the intersection point may be the end point of only one fence. Given a fence layout, calculate if there is a way for Farmer John to ride his horse to all of his fences without riding along a fence more than once. Farmer John can start and finish anywhere, but cannot cut across his fields (i.e., the only way he can travel between intersection points is along a fence). If there is a way, find one way. Graph: Farmer John starts at intersection points and travels between the points along fences. Thus, the vertices of the underlying graph are the intersection points, and the fences represent edges. Knight moves Given: Two squares on an 8x8 chessboard. Determine the shortest sequence of knight moves from one square to the other. Graph: The graph here is harder to see. Each location on the chessboard represents a vertex. There is an edge between two positions if it is a legal knight move. Overfencing [Kolstad & Schrijvers, Spring 1999 USACO Open] Farmer John created a huge maze of fences in a field. He omitted two fence segments on the edges, thus creating two ``exits'' for the maze. The maze is a `perfect' maze; you can find a way out of the maze from any point inside it. Given the layout of the maze, calculate the number of steps required to exit the maze from the `worst' point in the maze (the point that is `farther' from either exit when walking optimally to the closest exit). Here's what one particular W=5, H=3 maze looks like: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph10.gif > Graph: The vertices of the graph are positions in the grid. There is an edge between two vertices if they represent adjacent positions that are not separated by a wall. Terminology Let's look again at the first example graph: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph1.gif > An edge is a self-loop if it is of the form (u,u). The sample graph contains no self-loops. A graph is simple if it neither contains self-loops nor contains an edge that is repeated in E. A graph is called a multigraph if it contains a given edge more than once or contain self-loops. For our discussions, graphs are assumed to be simple. The example graph is a simple graph. An edge (u,v) is incident to both vertex u and vertex v. For example, the edge (1,3) is incident to vertex 3. The degree of a vertex is the number of edges which are incident to it. For example, vertex 3 has degree 3, while vertex 4 has degree 1. Vertex u is adjacent to vertex v if there is some edge to which both are incident (that is, there is an edge between them). For example, vertex 2 is adjacent to vertex 5. A graph is said to be sparse if the total number of edges is small compared to the total number possible ((N x (N-1))/2) and dense otherwise. For a given graph, whether it is dense or sparse is not well-defined. Directed Graph Graphs described thus far are called undirected, as the edges go `both ways'. So far, the graphs have connoted that if one can travel from vertex 1 to vertex 3, one can also travel from vertex 3 to vertex 1. In other words, (1,3) being in the edge set implies (3,1) is in the edge set. Sometimes, however, a graph is directed, in which case the edges have a direction. In this case, the edges are called arcs. Directed graphs are drawn with arrows to show direction. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph3.gif > The out-degree of a vertex is the number of arcs which begin at that vertex. The in-degree of a vertex is the number of arcs which end at that vertex. For example, vertex 6 has in-degree 2 and out-degree 1. A graph is assumed to be undirected unless specifically called a directed graph. Paths A path from vertex u to vertex x is a sequence of vertices (v 0, v 1, ..., v k) such that v 0 = u and v k = x and (v 0, v 1) is an edge in the graph, as is (v 1, v 2), (v 2, v 3), etc. The length of such a path is k. For example, in the undirected graph above, (4, 3, 1, 6) is a path. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph4.gif > This path is said to contain the vertices v 0, v 1, etc., as well as the edges (v 0, v 1), (v 1, v 2), etc. Vertex x is said to be reachable from vertex u if a path exists from u to x. A path is simple if it contains no vertex more than once. A path is a cycle if it is a path from some vertex to that same vertex. A cycle is simple if it contains no vertex more than once, except the start (and end) vertex, which only appears as the first and last vertex in the path. These definitions extend similarly to directed graphs (e.g., (v 0, v 1), (v 1, v 2), etc. must be arcs). Graph Representation The choice of representation of a graph is important, as different representations have very different time and space costs. The vertices are generally tracked by numbering them, so that one can index them just by their number. Thus, the representations focus on how to store the edges. Edge List The most obvious way to keep track of the edges is to keep a list of the pairs of vertices representing the edges in the graph. This representation is easy to code, fairly easy to debug, and fairly space efficient. However, determining the edges incident to a given vertex is expensive, as is determining if two vertices are adjacent. Adding an edge is quick, but deleting one is difficult if its location in the list is not known. For weighted graphs, this representation also keeps one more number for each edge, the edge weight. Extending this data structure to handle directed graphs is straightforward. Representing multigraphs is also trivial. Example The sample undirected graph might be represented as the following list of edges: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph11.gif > Adjacency Matrix A second way to represent a graph utilizes an adjacency matrix. This is a N by N array (N is the number of vertices). The i,j entry contains a 1 if the edge (i,j) is in the graph; otherwise it contains a 0. For an undirected graph, this matrix is symmetric. This representation is easy to code. It's much less space efficient, especially for large, sparse graphs. Debugging is harder, as the matrix is large. Finding all the edges incident to a given vertex is fairly expensive (linear in the number of vertices), but checking if two vertices are adjacent is very quick. Adding and removing edges are also very inexpensive operations. For weighted graphs, the value of the (i,j) entry is used to store the weight of the edge. For an unweighted multigraph, the (i,j) entry can maintain the number of edges between the vertices. For a weighted multigraph, it's harder to extend this. Example The sample undirected graph would be represented by the following adjacency matrix: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph12.gif > It is sometimes helpful to use the fact that the (i,j) entry of the adjacency matrix raised to the k-th power gives the number of paths from vertex i to vertex j consisting of exactly k edges. Adjacency List The third representation of graph is to keep track of all the edges incident to a given vertex. This can be done by using an array of length N, where N is the number of vertices. The ith entry in this array is a list of the edges incident to i'th vertex (edges are represented by the index of the other vertex incident to that edge). This representation is much more difficult to code, especially if the number of edges incident to each vertex is not bounded, so the lists must be linked lists (or dynamically allocated). Debugging this is difficult, as following linked lists is more difficult. However, this representation uses about as much memory as the edge list. Finding the vertices adjacent to each node is very cheap in this structure, but checking if two vertices are adjacent requires checking all the edges adjacent to one of the vertices. Adding an edge is easy, but deleting an edge is difficult, if the locations of the edge in the appropriate lists are not known. Extend this representation to handle weighted graphs by maintaining both the weight and the other incident vertex for each edge instead of just the other incident vertex. Multigraphs are already representable. Directed graphs are also easily handled by this representation, in one of several ways: store only the edges in one direction, keep a seperate list of incoming and outgoing arcs, or denote the direction of each arc in the list. Example The adjacency list representation of the example undirected graph is as follows: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph132.gif > Implicit Representation For some graphs, the graph itself does not have to be stored at all. For example, for the Knight moves and Overfencing problems, it is easy to calculate the neighbors of a vertex, check adjacency, and determine all the edges without actually storing that information, thus, there is no reason to actually store that information; the graph is implicit in the data itself. If it is possible to store the graph in this format, it is generally the correct thing to do, as it saves a lot on storage and reduces the complexity of your code, making it easy to both write and debug. If N is the number of vertices, M the number of edges, and d max the maximum degree of a node, the following table summarizes the differences between the representations: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph142.gif > Connectedness An undirected graph is said to be connected if there is a path from every vertex to every other vertex. The example graph is not connected, as there is no path from vertex 2 to vertex 4. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph1.gif > However, if you add an edge between vertex 5 and vertex 6, then the graph becomes connected. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph2.gif > A component of a graph is a maximal subset of the vertices such that every vertex is reachable from each other vertex in the component. The original example graph has two components: {1, 3, 4, 6} and {2, 5}. Note that {1, 3, 4} is not a component, as it is not maximal. A directed graph is said to be strongly connected if there is a path from every vertex to every other vertex. A strongly connected component of a directed graph is a vertex u and the collection of all vertices v such that there is a path from u to v and a path from v to u. Subgraphs Graph G' = (V', E') is a subgraph of G = (V, E) if V' is a subset of V and E' is a subset of E. The subgraph of G induced by V' is the graph (V', E'), where E' consists of all the edges of E that are between members of V'. For example, for V' = {1, 3, 4, 2}, the subgraph induced is: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph5.gif > Special Graphs An undirected graph is said to be a tree if it contains no cycles and is connected. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph6.gif > Many trees are what is called rooted, where there is a notion of the "top" node, which is called the root. Thus, each node has one parent, which is the adjacent node which is closer to the root, and may have any number of children, which are the rest of the nodes adjacent to it. The tree above was drawn as a rooted tree. An undirected graph which contains no cycles is called a forest. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph7.gif > A directed acyclic graph is often referred to as a dag. A graph is said to be complete if there is an edge between every pair of vertices. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph8.gif > A graph is said to be bipartite if the vertices can be split into two sets V 1 and V 2 such there are no edges between two vertices of V 1 or two vertices of V 2. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1069/graph9.gif >

 

 

 

0

 

USACO教程:Graph Theory图论知识

2017-03-18 12:03:24

1

64

N

3

3

0

1070

【栈、队列】USACO教程:Flood Fill种子染色法

Flood Fill 种子染色法 译 by Lucky Crazy & Felicia Crazy Flood Fill 按原意应翻译成水流式填充法(如果我没译错),有些中文书籍上将它称作种子染色法,然而大部分的书籍(包括中文书籍)都直接引用其英文原名:Flood Fill。介于此,下文所有涉及到Flood Fill的都直接引用英文 ——译者) 样例: 相连的农场 Farmer John的农场被一次意外事故破坏了,有一些农场与其他的农场之间有道路相连,而有些道路却已被破坏。这使得Farmer John 无法了解到从一个农场能否到达另一个农场。你的任务就是帮助Farmer John来了解哪些农场是连通的。 给出: 上题实际上就是要求寻找一张无向图的所有极大连通子图。 给出一张未知连通性的图,如下图: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood1.gif > 可知,该图的极大连通子图是:{1,4,8} {2,5,6,7,9}  {3}。 算法: Flood Fill Flood Fill 可以用深度优先搜索,广度优先搜索或广度优先扫描来实现。他的实现方式是寻找到一个未被标记的结点对它标记后扩展,将所有由它扩展出的结点标上与它相同的标号,然后再找另一个未被标号的 结点重复该过程。这样,标号相同的结点就属于同一个连通子图。 深搜:取一个结点,对其标记,然后标记它所有的邻结点。对它的每一个邻结点这么一直递归下去完成搜索。 广搜:与深搜不同的是,广搜把结点加入队列中。 广度扫描(不常见):每个结点有两个值,一个用来记录它属于哪个连通子图(c),一个用来标记是否已经访问(v)。算法对每一个未访问而在某个连通子图当中的结点扫描,将其标记访问,然后把它的邻结点的(c)值改为当前结点的(c)值。 深搜最容易写,但它需要一个栈。搜索显式图没问题,而对于隐式图,栈可能就存不下了。 广搜稍微好一点,不过也存在问题。搜索大的图它的队列有可能存不下。深搜和广搜时间复杂度均为O(N+M)。其中,N为结点数,M为边数。 广度扫描需要的额外空间很少,或者可以说根本不要额外空间,但是它很慢。时间复杂度是O(N^2+M)。 (实际应用中,我们一般写的是DFS,因为快。空间不是问题,DFS可改用非递归的栈操作完成。但为了尊重原文,我们还是译出了广度扫描的全过程。——译者) 广度扫描的伪代码 代码中用了一个小技巧,因此无须额外空间。结点若未访问,将其归入连通子图(-2),就是代码里的component -2。这样无须额外空间来记录结点是否访问,请读者用心体会。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood2.gif > 算法的时间复杂度是 O(N 2),每个结点访问一次,每条边经过两次。 实例 考虑刚才的那张图: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood3.gif > 开始时,所有的结点都没有访问。(下例中未访问被表示为 -2) 首先从结点1开始,结点1未访问,那么先处理结点1,将它归入连通子图1 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood4.gif > 标记完成后,对它进行第一步的扩展,由结点4和结点8与结点1连通,故它们被扩展出来。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood5.gif > 之后,先处理结点4,将它与结点1归入相同的连通子图。现在它没有可扩展的结点了(结点1已被扩展过)   <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood6.gif > 接着处理结点8。结果与结点4一样。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood7.gif > 现在,所有与结点1连通的结点都已扩展,标号为1的连通子图产生了。那么我们将跳出扩展步骤,寻找下一个连通子图,标号为2。 与上一步相同的顺序,找到结点2 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood8.gif > 扩展结点2,结点7与结点9出现。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood9.gif > 下一步,扩展结点7,结点5出现。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood10.gif > 然后是结点9 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood11.gif > 扩展结点5。结点6出现。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood12.gif > 很遗憾,结点6没有可供扩展的结点。至此连通子图2产生。   <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood13.gif > 之后寻找连通子图3,至此,仅有结点3未被扩展。   <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood14.gif > 结点3没有可供扩展的结点,这样,结点3就构成了仅有一个结点的连通子图3。   <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood15.gif > 结点3处理结束后,整个图的所有9个结点就都被归入相应的3个连通子图。Flood Fill 结束。 问题提示 这类问题一般很清晰,求解关于连通的问题会用到 Flood Fill。它也很经常用作某些算法的预处理。 扩展与延伸 有向图的连通性比较复杂。 同样的填充算法可以找出从一个结点能够到达的所有结点。每一层递归时,若一个结点未访问,就将其标记为已访问(表示他可以从源结点到达),然后对它所有能到达且为访问的结点进行下一层递归。 若要求出可以到达某个结点的所有结点,你可以对后向弧做相同的操作。 例题 控制公司 [有删节, IOI 93] 已知一个带权有向图,权值在0-100之间。 如果满足下列条件,那么结点A“拥有结点B A = B AB有一条权值大于50的有向弧。 存在一系列结点 C 1  C k 满足 A 拥有 C 1  C k, 每个节点都有一条弧到B,记作x 1 x 2 ...x k,并且 x 1 + x 2 + ... + x k > 50。 找出所有的(AB)对,满足A拥有B。 分析:这题可以用上面提到的给出一个源,在有向图中找出它能够到达的结点算法的改进版解决。要计算A拥有的结点,要对每个结点计算其控股百分比。把它们全部设为0。现在,在递归的每一步中,将其标记为属于A并把它所有出弧的权加到控股百分比中。对于每个控股百分比超过50的结点,进行同样的操作(递归)。   街道赛跑 [IOI 95] 已知一个有向图,一个起点和一个终点。 找出所有的p,使得从起点到终点的任何路径都必须经过p。 分析:最简单的算法是枚举p,然后把p删除,看看是否存在从起点到终点的通路。时间复杂度为O(N (M + N))。题目的数据范围是 M <= 100, N <= 50,不会超时。 牛路 [1999 USACO 国家锦标赛, 有删节] 连通图的直径定义为图中任意两点间距离的最大值,两点间距离定义为最短路的长。 已知平面上一个点集,和这些点之间的连通关系,找出不在同一个连通子图中的两个点,使得连接这两个点后产生的新图有最小的直径。 分析:找出原图的所有连通子图,然后枚举不在同一个连通子图内的每个点对,将其连接,然后找出最小直径。 笨蛋建筑公司 Farmer John 计划建造一个新谷仓。不幸的是,建筑公司把他的建造计划和其他人的建造计划混淆了。Farmer John 要求谷仓只有一个房间,但是建筑公司为他建好的是有许多房间的谷仓。已知一个谷仓平面图,告诉Farmer John 它一共有多少个房间。 分析:随便找一个格子,遍历所有与它连通的格子,得到一个房间。然后再找一个未访问的格子,做同样的工作,直到所有的格子均已访问。虽然题目给你的不是直接的图,但你也可以很容易地对其进行Flood Fill

Flood Fill Sample Problem: Connected Fields Farmer John's fields are broken into fields, with paths between some of them. Unfortunately, some fields are not reachable from other fields via the paths. Define a superfield is a collection of fields that are all reachable from each other. Calculate the number of superfields. The Abstraction Given: a undirected graph The component of a graph is a maximal-sized (though not necessarily maximum) subgraph which is connected. Calculate the component of the graph. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood1.gif > This graph has three components: {1,4,8}, {2,5,6,7,9}, and {3}. The Algorithm: Flood Fill Flood fill can be performed three basic ways: depth-first, breadth-first, and breadth-first scanning. The basic idea is to find some node which has not been assigned to a component and to calculate the component which contains. The question is how to calculate the component. In the depth-first formulation, the algorithm looks at each step through all of the neighbors of the current node, and, for those that have not been assigned to a component yet, assigns them to this component and recurses on them. In the breadth-first formulation, instead of recursing on the newly assigned nodes, they are added to a queue. In the breadth-first scanning formulation, every node has two values: component and visited. When calculating the component, the algorithm goes through all of the nodes that have been assigned to that component but not visited yet, and assigns their neighbors to the current component. The depth-first formulation is the easiest to code and debug, but can require a stack as big as the original graph. For explicit graphs, this is not so bad, but for implicit graphs, such as the problem presented has, the numbers of nodes can be very large. The breadth-formulation does a little better, as the queue is much more efficient than the run-time stack is, but can still run into the same problem. Both the depth-first and breadth-first formulations run in N + M time, where N is the number of vertices and M is the number of edges. The breadth-first scanning formulation, however, requires very little extra space. In fact, being a little tricky, it requires no extra space. However, it is slower, requiring up to N*N + M time, where N is the number of vertices in the graph. Pseudocode for Breadth-First Scanning This code uses a trick to not use extra space, marking nodes to be visited as in component -2 and actually assigning them to the current component when they are actually visited. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood2.gif > Running time of this algorithm is O(N 2), where N is the numbers of nodes. Every edge is traversed twice (once for each end-point), and each node is only marked once. Execution Example Consider the graph from above. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood3.gif > The algorithm starts with all nodes assigned to no component. Going through the nodes in order first node not assigned to any component yet is vertex 1. Start a new component (component 1) for that node, and set the component of node 1 to -2 (any nodes not shown are unassigned). <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood42.gif > Now, in the flood_fill code, the first time through the do loop, it finds the node 1 is assigned to component -2. Thus, it reassigns it to component 1, signifying that it has been visited, and then assigns its neighbors (node 4) to component -2. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood52.gif > As the loop through all the nodes continues, it finds that node 4 is also assigned to component -2, and processes it appropriately as well. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood62.gif > Node 8 is the next to be processed. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood72.gif > Now, the for loop continues, and finds no more nodes that have not been assigned yet. Since the until clause is not satisfied ( num_visited = 3), it tries again. This time, no nodes are found, so the function exits and component 1 is complete. The search for unassigned nodes continues, finding node 2. A new component (component 2) is allocated, node 2 is marked as in component -2, and flood_fill is called. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood82.gif > Node 2 is found as marked in component -2, and is processed. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood92.gif > Next, node 7 is processed. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood102.gif > Then node 9 is processed. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood112.gif > The terminating condition does not hold ( num_visited = 3), so the search through for nodes assigned to component -2 starts again. Node 5 is the first one found. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood122.gif > Node 6 is the next node found to be in component -2. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood132.gif > No more nodes are found assigned to component -2, but the terminating condition does not hold, so one more pass through the nodes is performed, finding no nodes assigned to component -2. Thus, the search for unassigned nodes continue from node 2, finding node 3 unassigned. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood142.gif > Node 3 is processed. <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood152.gif > From here, the algorithm eventually terminates, as there are no more nodes assigned to component -2 and no unassigned nodes. The three components of the graph have been determined, along with the component to which each node belongs. Problem Cues Generally, these types of problem are fairly clear. If it asks for sets of "connected" things, it's probably asking for components, in which case flood fill works very well. Often, this is a step in solving the complete problem. Extensions The notion of ``components'' becomes muddied when you go to directed graphs. However, the same flooding idea can be used to determine the points which are reachable from any given point even in a directed graph. At each recursive step, if the point isn't marked already, mark the point as reachable and recurse on all of its neighbors. Note that to determine which points can reach a given point in a directed graph can be solved the same, by looking at every arc backwards. Sample Problems Company Ownership [abridged, IOI 93] Given: A weighted directed graph, with weights between 0 and 100. Some vertex A ``owns'' another vertex B if: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1070/flood162.gif > Find all (a,b) pairs such that a owns b. Analysis: This can be solved via an adaptation of the calculating the vertices reachable from a vertex in a directed graph. To calculate which vertices vertex A owns, keep track of the ``ownership percentage'' for each node. Initialize them all to zero. Now, at each recursive step, mark the node as owned by vertex A and add the weight of all outgoing arcs to the ``ownership percentages.'' For all percentages that go above 50, recurse into those vertices. Street Race [IOI 95] Given: a directed graph, and a start point and an end point. Find all points p that any path from the start point to the end must travel through p. Analysis: The easiest algorithm is to remove each point in turn, and check to see if the end point is reachable from the start point. This runs in O(N (M + N)) time. Since the original problem stated that M <= 100, and N <= 50, this will run in time easily. Cow Tours [1999 USACO National Championship, abridged] The diameter of a connected graph is defined as the maximum distance between any two nodes of the graph, where the distance between two nodes is defined as the length of the shortest path. Given a set of points in the plane, and the connections between those points, find the two points which are currently not in the same component, such that the diameter of the resulting component is minimized. Analysis: Find the components of the original graph, using the method described above. Then, for each pair of points not in the same component, try placing a connection between them. Find the pair that minimizes the diameter. Connected Fields Farmer John contracted out the building of a new barn. Unfortunately, the builder mixed up the plans of Farmer John's barn with another set of plans. Farmer John's plans called for a barn that only had one room, but the building he got might have many rooms. Given a grid of the layout of the barn, tell Farmer John how many rooms it has. Analysis: The graph here is on the non-wall grid locations, with edge between adjacent non-wall locations, although the graph should be stored as the grid, and not transformed into some other form, as the grid is so compact and easy to work with.

 

第一行两个整数nmn表示无向图中结点个数,m表示图中边的数量); 接下来共计m行,表示有m条边,每一条边对就的一对结点。 如: 10 9 1 4 1 8 2 7 2 9 3 10 5 6 5 7 5 9 7 9

输出为行,一个整数k(表示该无向图中有多少个极大连通子图) 3

0

 

USACO教程:Flood Fill种子染色法

2017-03-18 12:03:24

1

64

N

0

3

0

1071

USACO_2.1-3:Sorting Three-Valued三值排序

Sorting a Three-Valued Sequence三值的排序 描述 排序是一种很频繁的计算任务。现在考虑最多只有三值的排序问题。一个实际的例子是,当我们给某项竞赛的优胜者按金银铜牌序的时候。在这个任务中可能的值只有三种123。我们用交换的方法把他排成升序的。 写一个程序计算出,给定的一个1,2,3组成的数字序列,排成升序所需的最少交换次数。

Line 1: N (1 <= N <= 1000) Lines 2-N+1: 每行一个数字,共N行。(1..3

共一行,一个数字。表示排成升序所需的最少交换次数。

9 2 2 1 3 3 3 2 3 1

4

0

 

USACO_2.1-3

2017-03-18 12:03:24

1

64

N

2

3

0

1072

USACO_2.1-4:Healthy Holsteins健康霍斯坦奶牛

农民JOHN以拥有世界上最健康的奶牛为骄傲。他知道每种饲料中所包含的的牛所需的最低的维他命量是多少。请你帮助农夫喂养他的牛,以保持它们的健康,使喂给牛的饲料的种数最少。 给出牛所需的最低的维他命量,输出喂给牛需要哪些种类的饲料,且所需的饲料剂量最少。 维他命量以整数表示,每种饲料最多只能对牛使用一次,数据保证存在解。

1行:一个整数V(1<=V<=25),表示需要的维他命的种类数。 第2行:V个整数(1<=每个数<=1000),表示牛每天需要的维他命的最小量。 第3行:一个整数G(1<=G<=15),表示可用来喂牛的饲料的种数。下面G行,第i行表示编号为i饲料包含的各种维他命的量的多少。

输出文件只有一行,包括: 牛必需的最小的饲料种数P 后面有P个数,表示所选择的饲料编号(按从小到大排列)。 (如果饮料种数P相同的解有多个的话,选择输出的解是其中所有总维他命最少的那个解)

4 100 200 300 400 3 50 50 50 50 200 300 200 300 900 150 389 399

2 1 3

0

 

USACO_2.1-4

2017-03-18 12:03:24

100

591

N

5

7

0

1073

USACO_2.1-5:Hamming Codes海明码

给出 NB  D:找出 N 个编码(1 <= N <= 64),每个编码有 B [二进制]1 <= B <= 8),使得两两编码之间至少有 D 个单位的海明距离1 <= D <= 7)。海明距离是指对于两个编码,他们的二进制表示法中的不同二进制位的数目。看下面的两个编码 0x554  0x234 之间的区别(0x554 表示一个十六进制数,每个位上分别是 554: 0x554 = 0101 0101 0100 0x234 = 0010 0011 0100(不是将每一位分别转为2进制,这里空格只是为了方便演示) 不同位: xxx xx 因为有五个位不同,所以海明距离 5

一行,包括 N, B, D

N 个编码(用十进制表示),要排序,十个一行。 如果有多解,你的程序要输出这样的解:假如把它化为 2^B 进制的数,它的值要最小。

16 7 3

0 7 25 30 42 45 51 52 75 76 82 85 97 102 120 127

0

必须与其他所有的数相比,并且海明码都符合要求,这个数才正确! 还有就是最后一行数据不管有没有10个,都必须换行。格式就是这样!

USACO_2.1-5

2017-03-18 12:03:24

1

64

N

1

2

0

1074

USACO教程:Data Structures

 

Data Structures Prerequisite Graph Theory How to pick the perfect data structure There are several aspect of data structures to consider when selecting the proper way to represent the data for a problem. Will it work? If the data struct won't work, it's not helpful at all. Ask yourself what questions the algorithm will need to be able to ask the data structure, and make sure the data structure can handle it. If not, then either more data must be added to the structure, or you need to find a different representation. Can I code it? If you don't know or can't remember how to code a given data structure, pick a different one. Make sure that you have a good idea how each of the operations will affect the structure of the data. Another consideration here is memory. Will the data structure fit in the available memory? If not, compact it or pick a new one. Otherwise, it is already clear from the beginning that it won't work. Can I Code It In Time? As this is a timed contest, you have three to five programs to write in five hours. If it'll take you an hour and a half to code just the data structure for the first problem, then you're almost certainly looking at the wrong structure. Can I Debug It? It is easy to forget this particular aspect of data structure selection. Remember that a program is useless unless it works. Don't forget that debugging time is a large portion of the contest time, so include its consideration in calculating coding time. What makes a data structure easy to debug? That is basically determined by the following two properties. State Is Easy To Examine The smaller, more compact the representation, in general, the easier it is to examine. Also, statically allocated arrays are much easier to examine than linked lists or even dynamically allocated arrays. State can Be Displayed Easily For the more complex data structures, the easiest way to examine them is to write a small routine to output the data. Unfortunately, given time constraints, you'll probably want to limit yourself to text output. This means that structures like trees and graphs are going to be difficult to examine. Is It Fast? This is, surprisingly, the least important consideration when picking a data structure. A slow program will normally get a noticeable portion of the points, but a fast, incorrect one will not, unless it gets lucky. Conclusion In general, remember the KISS principle: ``Keep It Simple, Stupid.'' Sometimes more complexity is very helpful, but make sure you're getting your money's worth. Remember that taking the time to make sure you've got the correct data structure at the start is a lot less expensive than having to replace a data structure later. Things to Avoid: Dynamic Memory In general, you should avoid dynamic memory, because: It Is Too Easy To Make Mistakes Using Dynamic Memory Overwriting past allocated memory, not freeing memory, and not allocating memory are only some of the mistakes that are introduced when dynamic memory is used. In addition, the failure modes for these errors are such that it's hard to tell where the error occurred, as it's likely to be at a (potentially much later) memory operation. It Is Too Hard To Examine the Data Structure's Contents The interactive development environments available don't handle dynamic memory well, especially for C. Consider parallel arrays as an alternative to dynamic memory. One way to do a linked list, where instead of keeping a next point, you keep a second array, which has the index of the next element. Sometimes you may have to dynamically allocate these, but as it should only be done once, it's much easier to get right than allocating and freeing the memory for each insert and delete. All of this notwithstanding, sometimes dynamic memory is the way to go, especially for large data structures where the size of the structure is not known until you have the input. Things to Avoid: Coolness Factor Try not to fall into the ``coolness'' trap. You may have just seen the neatest data structure, but remember: Cool ideas that don't work aren't. Cool ideas that'll take forever to code aren't, either It's much more important that your data structure and program work than how impressive your data structure is. Basic Structures There are five basic data structures: arrays, linked lists, stacks, queues, and deque (pronounced deck). You might have seen these structures before. If you have not, consult Sedgewick for what they are. Binary Search Trees Binary search trees enable you to search a collection of objects (each with a real or integer value) quickly to determine if a given value exists in the collection. Basically, a binary search tree is a weighted, rooted binary ordered tree. That collection of adjectives means that each node in the tree might have one `right' child and one `left' child (but both or either could be missing). In addition, each node has an object associated with it, and the `weight' of the node is the value of the object. The binary search tree also has the property that each node's left child and descendants of its left child have a value less than that of the node, and each node's right child and its descendants have a value greater or equal to it. The nodes are generally represented as a structure with four fields, a pointer to the node's left child, a pointer to the node's right child, the weight of the object stored at this node, and a pointer to the object itself. Why Are Binary Search Trees Useful? Given a collection of N objects, a binary search tree takes only O(log N) time to find an objects, assuming that the tree is not really poor (a tree where each node has no left child means the search will take O(N) time, for example). In addition, unlike just keeping a sorted array, inserting and deleting objects only takes log N time as well. Variations on Binary Trees Sometimes it's helpful to provide a link to a node's parent as well. There are several variants that ensure that the trees are never poor. Splay trees, Red-black trees, Treaps, B-trees, and AVL trees are some of the more common examples. They are all much more complicated to code, and random trees are generally good, so it's generally not worth it. If you're concerned that the tree you created might be bad (it's being created by inserting elements from an input file, for example), then randomly order the elements before insertion. Hash Tables A hash table stores data with a very quick way to do lookups. Let's say there is a collection of objects and a data structure must quickly answer the question: ``Is this object in the data structure?'' (e.g., is this word in the dictionary?). A hash table does this in less time than it takes to do binary search. The idea is this: find a function that maps the elements of the collection to an integer between 1 and x (where x, in this explanation, is larger than the number of elements in your collection). Keep an array indexed from 1 to x, and store each element at the position that the function evaluates the element as. Then, to determine if something is in your collection, just plug it into the function and see whether or not that position is empty. If it is not check the element there to see if it is the same as the something you're holding, For example, presume the function is defined over 3-character words, and is (first letter + (second letter * 3) + (third letter * 7)) mod 11 (A=1, B=2, etc.), and the words are ``CAT'', ``CAR'', and ``COB''. When using ASCII, this function takes ``CAT'' and maps it to 3, maps ``CAR'' to 0, and maps ``COB'' to 7, so the hash table would look like this: 0: CAR 1 2 3: CAT 4 5 6 7: COB 8 9 10 Now, to see if ``BAT'' is in the table, plug it into the hash function to get 2. This position in the hash table is empty, so it is not in the collection. ``ACT'', on the other hand, returns the value 7, so the program must check to see if that entry, ``COB'', is the same as ``ACT''. Consider this function: #define NHASH 8999 /* make sure this is prime! */ hashnum(p) char *p; { unsigned int sum = 0; for ( ; *p; p++) sum = (sum << 3) + *p; return sum % NHASH; } This function will return *some* integer in the range 0..NHASH-1 for every input. As it turns out, the output is fairly random. this simple function for NHASH to be prime. Combine the above with a main program: #include main() { FILE *in; char line[100], *p; in = fopen ("/usr/share/dict/words", "r"); while (fgets (line, 100, in)) { for (p = line; *p; p++) if (*p == '\n') { *p = '\0'; break; } printf("%6d %s\n", hashnum(line), line); } exit (0); } to yield numbers like this for the (start of the) english dictionary: 4645 aback 4678 abaft 6495 abandon 2634 abandoned 4810 abandoning 142 abandonment 7080 abandons 4767 abase 2240 abased 7076 abasement 4026 abasements 2255 abases 4770 abash 222 abashed 237 abashes 2215 abashing 361 abasing 4775 abate 2304 abated 3848 abatement ... ... You can see that the function yields numbers that are all different and are fairly random looking, at least in this small sample. Of course, if one has NHASH+1 words, the pigeon-hole principle says that at leaast one pair of them will yield the same function value. This is called a 'collision'. Pragmatic hash tables use a list of length NHASH to represent the head of NHASH linked lists of words that all hashed to the same value. Let's see how hashing is really used. First, start with a structure that forms a linked list off the hash table. The linked list structure looks like this: struct hash_f { struct hash_f *h_next; char *h_string; int h_value; /* some value associated with the string */ /* completely optional how it's used or even if it's present */ }; struct hash_f *hashtable[NHASH]; /* the head of each linked list */ /* automatically set to NULL since it's global */ This makes a hash table that would look like this if two elements were present: hashtable *hash_f *hash_f +------------+ 0 | | +-----------+ +-----------+ +------------+ | *|-+ | 0| 1 | | +-----------+ | +-----------+ +------------+ | 'string1' | | | 'abc def' | 2 | * |->+-----------+ +->+-----------+ +------------+ | val=1234 | | val=43225 | 3 | | +-----------+ +-----------+ +------------+ ... 8998 | | +------------+ Here's hashinsert: struct hash_f * hashinsert(p, val) char *p; int val; { int n = hashnum(p); /* where in table? */ char *h = malloc( sizeof (struct hash_f) ); /* make a new hash element */ /* link into start of list: */ h->h_next = hashtable[n]; hashtable[n] = h; /* optional value: */ h->h_val = val; /* so we can later find the proper element in this chain: */ h->h_string = malloc( strlen(p) + 1 ); strcpy (h->h_string, p); return h; } And here's hashlookup (which will return a pointer to the hash structure if it's found): struct hash_f * hashlookup(p) { struct hash_f *h; int n = hashnum(p); /* where to start looking */ for (h = hashtable[n]; h; h=h->h_next) /* traverse linked list */ if (0 == strcmp (p, h->h_string)) /* string match? done! */ return h; return 0; /* didn't find target */ } Now you can insert strings quickly and look them up quickly, in size_of_linked_list/2 string compares, on average. Why Are Hash Tables Useful? Hash tables enable, with a little bit of memory cost, programs to perform lookups with almost constant work. Generally, the program must evaluate the function and then possibly compare the looked up element to an entry or a few entries in the table. Hashers A more subtle, and often forgotten, technique to avoid collisions is to pick a good hash function. For example, taking the three letter prefix as the hash value for a dictionary would be very bad. Under this hash function, the prefix ``CON'' would have a huge number of entries. Pick a function where two elements are unlikely to map to the same value: Create a relatively huge value and mod it with the size of your table (this works especially well if your hash table is a prime size). Primes are your friends. Multiply by them. Try to have small changes map to completely different locations. You don't want to have two small changes cancel each other out in your mapping function (a transposition, for example). This is a whole field of study, and you could create a ``Perfect Hash Function'' that would give you no collisions, but, for your purposes, that's entirely too much work. Pick something that seems fairly random, and see if it works; it probably will. Hash Table Variations It is often quite useful to store more information that just the value. One example is when searching a small subset of a large subset, and using the hash table to store locations visited, you may want the value for searching a location in the hash table with it. Even a small hash table can improve runtime by drastically reducing your search space. For example, keeping a dictionary hashed by the first letter means that if you wanted to search for a word, you would only be looking at words that have the same first letter. Special Trees Called 'Tries' A trie is, in short, a rooted tree. It has unbounded out-degree (a node may logically have any number of children). The children of a node are stored in a linked list, so each node has two pointers, next sibling and first child. Tries store a collection of sequences. Every path from the root to a leaf specifies an element of that collection. For example, for the trie illustrated, the collection specified is ``CAR'', ``CAT'', and ``COB'', presuming no other nodes exist. To determine if a sequence is in the collection, start at the root, search through its children for the first element of that sequence. If no match is found, the sequence is not in the collection. Otherwise, search the children of that node similarly and for subsequent element. Tries sport several nice features. Checking to see if an element is in the list takes time bounded by the length of the sequence times the maximum number of children a node has. Additionally, this data structure can often use less memory than other representations, because prefixes only appear once (in our example, there is only one `CA' node even though `CAR' and `CAT' appear). In general, a trie is nice to use when you want to ask this question a lot: Does there exist a sequence (word, multi-digit number, or other type) that starts with this? Trie Variations Some common slight alterations to tries are: If your list may contain two words, one of which is a prefix of the other, you have to add a flag at each node which says ``A word ends here.'' For example, if you wanted to also have ``CA'' in your trie, it would have to be flagged. It sometimes helps to keep the linked list of children in sorted order. This increases the time to build the trie, but decreases the time to search it. If you have many words with similar prefixes but unique endings, it is sometimes helpful to put ``special'' nodes that stand for a sequence themselves. For example, if you want to represent ``CARTING,'' ``COBBLER,'' and ``CATCHING,'' memory constraints may make it more reasonable to represent a ``RTING,'' ``BBLER,'' and ``TCHING'' node. Note that this increases the complexity dramatically. Heap A heap (sometimes called a priority queue) is a complete binary tree in which every node's value is less than both of its children's values: Heap Representation If the tree is filled in from left to right level by level (that is, the tree is complete except for its lowest level, on which the elements are filled in from left to right), then the heap can be stored in an array, which is just the top level from left to right, the second level, and so on. The heap given would be: 3 5 9 6 12 13 10 8 11 In this representation, the children of the node at position x are 2x and 2x+1 (assuming 1 based indexing), and the parent of x is truncate(x/2). How Do I Add And Remove things To A Heap? To add an element, put it at the end of the array. Now, as long as it's below its current parent, swap it with its parent. For example, to add the number 4, the heap array would go through the following states: 3 5 9 6 12 13 10 8 11 4 3 5 9 6 4 13 10 8 11 12 3 4 9 6 5 13 10 8 11 12 Deleting an element is also relatively easy. Take the last element in the array and replace the element you wish to delete with it. While one of its children is less than it, pick the smaller of the two and swap with it. For example, to delete 3: 11 5 9 6 12 13 10 8 5 11 9 6 12 13 10 8 5 6 9 11 12 13 10 8 5 6 9 8 12 13 10 11 What If I Want To Alter A Value? To alter a value upwards, change the value, and swap with its parents as long as necessary. To alter a value downwards, change the value, and swap with the smaller of its two children as long as necessary. Why Would I Use This? A heap makes it very easy to ask the question ``What's the smallest thing?'' in a collection of dynamic values. It's a compact representation and quick to compute. An example of a location where this can be helpful is Dijkstra's algorithm. Heap Variations In this representation, just the weight was kept. Usually you want more data than that, so you can either keep that data and move it (if it's small) or keep pointers to the data. Since when you want to fiddle with values, the first thing you have to do is find the location of the value you wish to alter, it's often helpful to that data around. (e.g., node x is represented in location 16 of the heap).

 

 

 

0

 

USACO教程:Data Structures

2017-03-18 12:03:24

1

64

N

3

3

0

1075

USACO教程:Dynamic Programming动态规划

动态规划 引言 译 by (特别感谢,这是她在N次死机中译出来的) 作为显著减少算法运行时间(从指数的到多项式的)的一种编程技巧,动态规划是一个令人困惑的名字。它的基本思想是努力避免重复解决相同问题或子问题。如下面的问题证明了它的威力: 已知10000个整数的序列(整数大于0小于100000),求最长递减子序列。注意,子序列不一定非得连续。 递归下降解法 解决此问题显然的方法是递归下降。只需找到循环和一个终止条件。看看下面的解法: 1 #include <stdio.h> 2 long n, sequence[10000]; 3 main () { 4 FILE *in, *out; 5 int i; 6 in = fopen ("input.txt", "r"); 7 out = fopen ("output.txt", "w"); 8 fscanf(in, "%ld", &n); &a mp;n bsp; 9 for (i = 0; i < n; i++) fscanf(in, "%ld", &sequence[i]); 10 fprintf (out, "%d\n", check (0, 0, 99999)); 11 exit (0); 12 } 13 check (start, nmatches, smallest) { 14 int better, i, best=nmatches; 15 for (i = start; i < n; i++) { 16 if (sequence[i] < smallest) { 17 better = check (i, nmatches+1, sequence[i]); 18 & amp;n bsp; if (better > best) best = better; 19 } 20 } 21 return best; 22 } 1-9行和11-12行有疑义。它们创建了一些标准变量控制输入。秘密就在于第10行的递归程序‘check’‘check’程序知道它应该从哪开始查寻较小的整数,当前最长序列的长度及最小整数。由于额外调用的开销,当开始不超过其合适的范围,它就会自动地终止。‘check’程序本身很简单。它沿着列表寻找比当前‘smallest’更小的整数。如果找到了,‘check’递归调用它本身来寻找更多的整数。 同递归解法随之而来的问题是运行时间: N Seconds 60 0.130 70 0.360 80 2.390 90 13.190 由于序列的最大长度可能会接近6位数,这个解法是受限的。 从末端开始 当利用向前或从前面开始的方法无法运作时,从相反的方面开始处理问题却可以收获良多。像这个例子可以先从序列的末端开始。 另外,用一点儿存贮空间来交换执行效率也会获利很多。另一种程序可能会从序列的末尾开始,用一个辅助变量来记录当前最长递减(子)序列。 考虑长度为1的序列从末端开始的情况。任意长度为1的序列都满足最长序列的所有标准。本例将‘bestsofar’数组标记为‘1’。 考虑序列的最后两个元素。如果倒数第二个数字比最后那个大,那么‘bestsofar’21+最后那个数字的‘bestsofar’)。否则为1。 考虑在最后两个元素之前的任一元素。它总是比接近末尾的那个元素大。它的‘bestsofar’元素至少比找到的较小元素的大1。最后‘bestsofar’的最大值就是最长递减子序列的长度。 这很明显是一个 O(N 2)算法。代码如下: 1 #include <stdio.h> 2 #define MAXN 10000 3 main () { 4 long num[MAXN], bestsofar[MAXN]; 5 FILE *in, *out; 6 long n, i, j, longest = 0; 7 in = fopen ("input.txt", "r"); 8 out = fopen ("output.txt", "w"); 9 fscanf(in, "%ld", &n); 10 for (i = 0; i < n; i++) fscanf(in, "%ld", &num[i]); 11 bestsofar[n-1] = 1; 12 for (i = n-1-1;&am p;nb sp;i >= 0; i--) { 13 bestsofar[i] = 1; 14 for (j = i+1; j < n; j++) { 15 if (num[j] < num[i] && bestsofar[j] >= bestsofar[i]) { 16 bestsofar[i] = bestsofar[j] + 1; 17 if (bestsofar[i] > longest) longest = bestsofar[i]; 18 } 19 } 20 } 21 fprintf(out, "bestsofar is %d\n", longest); 22 exit(0); 23 } 同样地,11行建立了末尾条件。12-20行以‘i’循环从后计数和‘j’循环从前计数的巧妙直接的方法运行ON2)算法。尽管比前面的那个算法多1行,运行时间却更佳: N Secs 1000 0.080 2000 0.240 3000 0.550 4000 0.950 5000 1.450 6000 2.080 7000 2.990 8000 3.700 9000 4.700 10000 6.330 11000 7.350 N=9000时由于竞争,算法依就很慢。 内部循环(寻找任意较小的数)乞求用一些存储空间来交换时间。 一组不同的值最好存在辅助数组中。数组‘bestrun’的指针是最长子序列的长度,其值是率领子序列的第一个(也被证明是最佳的)整数。执行该数组。当遇到一个整数比在这个数组中的值大时就意味着可能会产生一个新的更长的序列。新整数可能是一个新的序列最佳首部,也可能不是。看下面这个序列: 10 8 9 4 6 3 从右向左浏览(从后向前),遇到3之后‘bestrun’数组有且只有一个元素: 03 继续浏览,63大,‘bestrun’数组变成: 0:3 1:6 4不比6大,但它比3大,所以数组变为: 0:3 1:4 9使数组增大为: 0:3 1:4 2:9 84使数组变成: 0:3 1:4 2:8 l0再次扩增数组为: 0:3 1:4 2:8 3:10 于是结果出来了:4(数组中有4个元素)。 因为‘bestrun’数组可能比处理过的序列长度增长得慢,这个算法可能比上一个运行得要快。实际上是增速很多。代码如下: 1 #include <stdio.h> 2 #define MAXN 200000 3 main () { 4 FILE *in, *out; 5 long num[MAXN], bestrun[MAXN]; 6 long n, i, j, highestrun = 0; 7 in = fopen ("input.txt", "r"); 8 out = fopen ("output.txt", "w"); 9 fscanf(in, "%ld", &n); 10 for (i = 0; i < n; i++) fscanf(in, "%ld", &num[i]); 11 bestrun[0] = num[n-1]; 12 highestrun = 1; 13 for (i = n-1-1; i >= 0; i--) { 14 if (num[i] < bestrun[0]) { 15 bestrun[0] = num[i]; 16 continue; 17 } 18 for (j = highestrun - 1; j >= 0; j--) { 19 if (num[i] > bestrun[j]) { 20 if (j == highestrun - 1 || num[i] < bestrun[j+1]){ 21 bestrun[++j] = num[i]; 22 if (j == highestrun) highestrun++; 23 break; 24 } 25 } 26 } 27 } 28 printf("best is %d\n", highestrun); 29 exit(0); 30 } 同样地,11-12行是初始化。14-17行是对一个新的最小的元素优化。它们可以放在26行之后。通常,这些行只能影响输入以最坏方式分类的这种最糟糕情况的算法。 18-26行查找‘bestrun’列表并含括了所有异常和棘手的情况(大于第一个元素?在中间插入?数组溢出?)。不用背诵,你应该可以马上将该代码写出来。速度很重要。下表比较了本算法和上一个算法,加看出当N变成5位数时本算法仍工作得不错: N orig Improved 1000 0.080 0.030 2000 0.240 0.030 3000 0.550 0.050 4000 0.950 0.060 5000 1.450 0.080 6000 2.080 0.090 7000 2.990 0.110 8000 3.700 0.130 9000 4.700 0.140 10000 6.330 0.160 11000 7.350 0.170 20000 0.290 40000 0.570 60000 & ;nbs p; 0.910 80000 1.290 100000 2.220 Marcin Mika指出你可以将此算法如下化简: #include <stdio.h> #define SIZE 200000 #define MAX(x,y) ((x)>(y)?(x):(y)) int best[SIZE]; // best[] holds values of the optimal sub-sequence int main (void) { FILE *in = fopen ("input.txt", "r"); FILE *out = fopen ("output.txt", "w"); int i, n, k, x, sol = -1; fscanf (in, "%d", &n); // N = how many integers to read in for (i = 0; i < n; i++) { best[i] = -1; fscanf (in, "%d", &x); for (k = 0; best[k] > x; k++) ; best[k] = x; sol = MAX (sol, k + 1); } printf ("best is %d\n", sol); return 0; } 为了不溢出,Tyler Lu指出: 目前存在的算法使用线性查找来寻找合适的位置在‘bestrun’数组中插入一个整数。但是,因为辅助数组已分好类,我们可以用二叉查找(OlogN))。这样对于大型序列我们的运行时间就降下来了。下面是将上面代码修改后的解法: #include <stdio.h> #define SIZE 200000 #define MAX(x,y) ((x)>(y)?(x):(y)) int best[SIZE]; // best[] holds values of the optimal sub-sequence int main (void) { FILE *in = fopen ("input.txt", "r"); int i, n, k, x, sol; int low, high; fscanf (in, "%d", &n); // N = how many integers to read in // read in the first integer fscanf (in, "%d", &best[0]); sol = 1; for (i = 1; i < n; i++) { best[i] = -1; fscanf (in, "%d", &x); if(x >= best[0]) { k = 0; best[0] = x; } else { // use binary search instead low = 0; high = sol-1; for(;;) { k = (int) (low + high) / 2; // go lower in the array if(x > best[k] && x > best[k-1]) { high = k - 1; continue; } // go higher in the array if(x < best[k] && x < best[k+1]) { low = k + 1; continue; } // check if right spot if(x > best[k] && x < best[k-1]) best[k] = x; if(x < best[k] && x > best[k+1]) best[++k] = x; break; } } sol = MAX (sol, k + 1); } printf ("best is %d\n", sol); fclose(in); return 0; } 摘要 这些程序证明了动态规划背后的主要构想:在先前找到的算法的基础上建立更大的算法。这种逐步建立的解法通常能产生速度非常快的程序。 由于前面编程的挑战,主要的子问题是:在已知元素的右侧数字中找到最大的递减子序列(及其第一个值)。 这种方法可解决被称为一维的一类问题。 二维动态规划 有时可能会创建如此的多维问题:已知两个整数序列,求二者的最长公共子序列。 这里,子问题就是较小序列(原来子序列末端部分)的最长公共子序列。首先,如果两序列之中的一个序列只含有一个元素,那解法就不重要了(或者所求元素在另一个序列中或者不在)。 考虑在第一个序列最后i个元素和在第二个元素最后j个元素中找到最长公共子序列的问题。有两种可能。第一个末尾部分的首元素可能在最大公共子序列中也可能不在。不包含第一个末尾部分首元素的最长公共序列就是第一个序列最后i-1个元素和第二个序列最后j个无素的最长公共子序列。第二个序列的末尾部分中某元素同第一个序列末尾部分的首元素一样且能找到在那些匹配元素之后元素的最长公共子序列,这导致了第二种可能。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1075/pic1.gif > 伪代码 下面是本算法的伪代码: # the tail of the second sequence is empty 1 for element = 1 to length1 2 length[element, length2+1] = 0 # the tail of the first sequence has one element 3 matchelem = 0 4 for element = length2 to 1 5 if list1[length1] = list2[element] 6 matchelem = 1 7 if matchelem = 0 then 8 length[length1,element] = 0 9 else 10 length[length1,e lement] = 1 # loop over the beginning of the tail of the first sequence 11 for loc = length1-1 to 1 12 maxlen = 0 13 for element = length2 to 1 # longest common subsequence doesn't include first element 14 if length[loc+1,element] > maxlen 15 maxlen = length[loc+1,element] # longest common subsequence includes first element 16 if list1[loc] = list2[element] 17 &nbs p; ; length[loc+1,element+1]+1 > maxlen 18 maxlen = length[loc,element+1] + 1 19 length[loc,element] = maxlen 这个程序的运行时间是ONxM),NM分别为序列的长度。 本算法并不直接计算最长公共子序列。但是,如果给出长度矩阵,你就可以很快地确定子序列了: 1 location1 = 1 2 location2 = 1 3 while (length[location1,location2] != 0) 4 flag = False 5 for element = location2 to length2 6 if (list1[location1] = list2[element] AND 7 length[location1+1,element+1]+1 = length[location1,location2] 8 output (list1[location1],list2[element]) 9 location2 = element + 1 10 flag = True 11 break for 12 location1 = location1 + 1 动态规划的技巧就是找到子问题来解决它。有时它需要多个参数: 振荡(???)序列是指第一部分递增且第二部分递减的序列。求一整数列的最长振荡序列(振荡可以是先增再减也可以是先减再增,但本问题只考虑先增加再减少的情况)。 这个问题的子问题是最长振荡序列和序列前缀的最长递减序列。 有时子问题被很好的隐藏起来了: 你刚赢得一场比赛,奖励是一份免费到加拿大的旅游。你必须乘飞机游玩,城市从东到西依次排列。另外,根据规则,你必须从最西侧的城市开始一直向东游览,直到你到达最东边的城市,再一直向西飞回到起点。另外每个城市参观一次(当然起点城市除外)。 已知城市顺序和乘坐的航班(你只能在某些城市间飞,因为你可以从A城飞到B城不意味着你可以向其它方向下),求你最多能参观多少个城市。 若使用动态规划应注意的是你的位置和你的方向,但重要的是你采用的路径(因为在回程时你不能再次参观某个己参观过的城市),而且路径数不能太多,否则将无法解出(并存贮)所有子问题的答案。 但是,如果不是寻找上面描述的路径,而是用另一不同的方式,那么状态数将大大减少。想像一下,有两个旅行者从最西侧的城市出发。两旅行者轮流向东走,而旅行者走的下一站总是最西侧的城市,但是两旅行者不能在同一个城市,除非他们在第一个或最后一个城市。但是,其中一个旅行者只允许使用相反的班次,即他可以从A城飞到B城当且仅当有一架从B城飞往A城的航班飞机。 从两个旅行者的路径中找到可以组合成一个环程旅行(用一个旅行者的正常路径飞到最东边的城市,然后再用另一个旅行者相反的路径返回最西侧的城市)并不太困难。而当旅行者x走了,你知道旅行者y除了他现在所在的城市外没参观过任何一个旅行者x东边的城市,否则xy西侧时旅行者y已经走过一次了。于是两旅行者的路径就无法接在一起了。此算法能产生参观城市最大值的原因留作练习。 通过动态规划将问题求解 一般地,动态规划解法应用在那些可能会花费指数级时间的算法上,因此如果有界限问题在任意但输入较少的情况下太大以至于不能以指数时间级运行时,可考虑使用动态规划法。基本上,任何问题你只要考虑到用递归下降的方法,如果输入不超过30就可以试试是否有动态规划的解法存在。 寻找子问题 如上所述,找到子问题是进行动态规划的重要一步。你的目的是用少量的数据,如一个整数、一对整数、一个布尔数和一个整数等等,完整地描述出算法的状态。 若不失败,子问题会是一个问题的尾端。也就是说,有一个进行递归下降的方法这样每一步你只能处理一小部分数据。举个例子,在飞行旅游的那道题中,你可从使用递归下降的方法找到完整的路径,那也意味着你得记住你的位置和你已参观过的城市(记城列表或布尔数组的形式)。这样动态规划要做的就太多了。但是在你向东飞的一对城市问使用递归给已知常数是需要递归的非常小的一部分数据。 如果路线很重要,除非路径很短,你不要使用动态规划。但是正如飞行旅行问题,路线也许不重要,就看你怎么看了。 示例题目 多边形游戏《1998 IOI》 想像一个均匀的N边形。结点处放入数字,边放入操作符‘+’‘x’。第一次去掉一条边。然后,合并边,即计算出操作符两边结点的值,将其代替原来的边和结点,举例如下: ...-- 3 --+-- 5 --*-- 7 --... ...----- 8 ----*----- 7 --... ...-------- 56 -----------... 已知一作好标记的N边形,求最后计算出的最大值。 子集和《春季98 USACO》 从1NN139之间)的连续整数的集合,可将其分成和相等的两个集合,例如,若N=3,将集合《123》分成《3》和《12》两个子集合且其和相等。这计为单独划分(如,反序计为同样的划分,并不增加划分数)。 若N=7,有4种方法将集合{1, 2, 3, ... 7} 分成和相等的两部分: {1,6,7} - {2,3,4,5} {2,5,7} - {1,3,4,6} {3,4,7} - {1,2,5,6} {1,2,4,7} - {3,5,6} 已知N,打印将从1N个整数的集合分成和相等的两个集合的各种方法。若没有则打印0。 数字游戏《IOI96 maybe》 已知不超过100个整数(-32000_32000)列,两个对手依次轮流从数列的最左边或最后边去掉一个数。游戏到最后每个玩家的分是他去掉的数的和。已知一数列,假设第二位玩家玩得非常好,求第一位玩家赢时的最高分。

 

 

 

 

0

 

USACO教程:Dynamic Programming动态规划

2017-03-18 12:03:24

1

64

N

3

3

0

1076

USACO_2.2-1:Preface Numbering序言页码

Preface Numbering 序言页码 译 by Jeru 一类书的序言是以罗马数字标页码的。传统罗马数字用单个字母表示特定的数值,一下是标准数字表: I V X L C D M 1 5 10 50 100 500 1000 最多3个可以表示为10n的数字(I,X,C,M)可以连续放在一起,表示它们的和: III=3 CCC=300 可表示为5x10n的字符(V,L,D)从不连续出现。 除了下一个规则,一般来说,字符以递减的顺序接连出现: CCLXVIII = 100+100+50+10+5+1+1+1 = 268 有时,一个可表示为10^n的数出现在一个比它大的数前(IVX前面,XLC前面,等等)。在这种情况下,数值等于后面的那个数减去前面的那个数: IV = 4 IX = 9 XL = 40 XD, IC, XM这样的表达是非法的,因为前面的数比后面的数小太多。对于XD(490的错误表达),可以写成 CDXC; 对于IC(99的错误表达),可以写成XCIX; 对于XM(990的错误表达),可以写成CMXC。 给定N(1 <= N < 3,500), 序言的页码数,请统计在第1页到第N也中,有几个I出现,几个V出现,等等 (从小到大的顺序)。不要输出并没有出现过的字符。 比如N = 5, 那么页码数为: I, II, III, IV, V. 总共有7I出现,2V出现。

一个整数N

每行一个字符和一个数字k,表示这个字符出现了k次。字符必须按数字表中的递增顺序输出。

5

I 7 V 2

0

 

USACO_2.2-1

2017-03-18 12:03:24

1

64

N

1

2

0

1077

USACO_2.2-2:Subset Sums集合

对于从1N (1 <= N <= 39) 的连续整数集合,能划分成两个子集合,且保证每个集合的数字和是相等的。举个例子,如果N=3,对于{123}能划分成两个子集合,他们每个的所有数字和是相等的: {3} and {1,2} 这是唯一一种分法(交换集合位置被认为是同一种划分方案,因此不会增加划分方案总数)如果N=7,有四种方法能划分集合{1234567},每一种分发的子集合各数字和是相等的: {1,6,7} and {2,3,4,5} { 1+6+7=2+3+4+5} {2,5,7} and {1,3,4,6} {3,4,7} and {1,2,5,6} {1,2,4,7} and {3,5,6} 给出N,你的程序应该输出划分方案总数,如果不存在这样的划分方案,则输出0。程序不能预存结果直接输出。

输入文件只有一行,且只有一个整数N

输出划分方案总数,如果不存在则输出0

7

4

0

 

USACO_2.2-2:Subset Sums集合

2017-03-18 12:03:24

1

64

N

2

3

0

1078

NOIP_1998.TG1:乘做火车

火车从始发站(称为第1站)开出,在始发站上车的人数为a,然后到达第2站,在第2站有人上、下车,但上、下车的人数相同,因此在第2站开出时(即在到达第3站之前)车上的人数保持为a人。 从第3站起(包括第3站)上、下车的人数有一定规律: 上车的人数都是前两站上车人数之和,而下车人数等于上一站上车人数,一直到终点站的前一站(第n-1站),都满足此规律。 现给出的条件是:共有N个车站,始发站上车的人数为a,最后一站下车的人数是m(全部下车)。 试问x站开出时车上的人数是多少?

输入:anmx

输出:从x站开出时车上的人数。

5 7 32 4

13

0

 

NOIP_1998.TG1:乘做火车

2017-03-18 12:03:24

1

64

N

9

13

0

1079

NOIP_1998.TG2:数据串联

设有n个正整数(n≤20),将它们联接成一排,组成一个最大的多位整数。 例如:n=3时, 3个整数13312343联接成的最大整数为:34331213 又如:n=4时, 4个整数7134246联接成的最大整数为:7424613

输入数据共两行: 第一行为一个整数,表示接下来输入整数的个数:nn≤20) 第二行为n个整数。

程序输出:联接成的最大的多位数

3 121 21 3

321121

0

 

NOIP_1998.TG2:数据串联

2017-03-18 12:03:24

1

64

N

17

27

0

1080

NOIP_1998.TG3:卢斯加法表

著名科学家卢斯为了检查学生对进位制的理解,他给出了如下的一张加法表,表中的字母代表数字。 例如: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1080.gif > 其含义为: L+L=LL+K=KL+V=VL+E=E K+L=KK+K=VK+V=EK+E=KL …… E+E=KV 根据这些规则可推导出:L=0K=1V=2E=3 同时可以确定该表表示的是4进制加法

程序输入: nn≤9)表示行数。 以下n行,每行包括n个字符串,每个字串间用空格隔开。(字串仅有一个为‘+’号,其它都由大写字母组成)

程序输出: 各个字母表示什么数,格式如:L=0K=1…… ② 加法运算是几进制的。 若不可能组成加法表,则应输出“ERROR

3 + M L M ML M L M L

M=1 L=0 2

0

 

NOIP_1998.TG3:卢斯加法表

2017-03-18 12:03:24

1

64

N

0

3

0

1081

NOIP_1999.TG1:拦截导弹

某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能高于前一发的高度。某天,雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹。 输入导弹依次飞来的高度(雷达给出的高度数据是不大于30000的正整数),计算这套系统最多能拦截多少导弹,如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

输入多个数据m:(m<=30000 389 207 155 300 299 170 158 65

6(最多能拦截的导弹数) 2(要拦截所有导弹最少要配备的系统数)

389 207 155 300 299 170 158 65

6 2

0

 

NOIP_1999.TG1:拦截导弹

2017-03-18 12:03:24

1

64

N

26

39

0

1082

NOIP_1999.TG2:回文数

若一个数(首位不为零)从左向右读与从右向左读都一样,我们就将其称之为回文数。 例如:给定一个10进制数56,将5665(即把56从右向左读),得到121是一个回文数。 又如:对于10进制数87 STEP187+78 = 165 STEP2165+561 = 726 STEP3726+627 = 1353 STEP41353+3531 = 4884 在这里的一步是指进行了一次N进制的加法,上例最少用了4步得到回文数4884。 写一个程序,给定一个N2<=N<=10N=16)进制数M,求最少经过几步可以得到回文数。 如果在30步以内(包含30步)不可能得到回文数,则输出“Impossible

输入数据共两行: 第一行:N进制,如:N = 9 第二行:N进制对应数字,如:M= 87

输出数据共一行,格式为: STEP=6

9 87

STEP=6

0

 

NOIP_1999.TG2:回文数

2017-03-18 12:03:24

1

64

N

6

7

0

1083

【贪心】NOIP_1999.TG3:旅行家的预算

一个旅行家想驾驶汽车以最少的费用从一个城市到另一个城市(假设出发时油箱是空的)。 给定两个城市之间的距离D1、汽车油箱的容量C(以升为单位)、每升汽油能行驶的距离D2、 出发点每升汽油价格P和沿途油站数NN可以为零),油站i离出发点的距离Di、每升汽油价格Pii=12……N)。 计算结果四舍五入至小数点后两位。如果无法到达目的地,则输出“No Solution”

输入数据可能有多行: 第1行: D1:两个城市之间的距离;C:汽车油箱的容量;D2:每升汽油能行驶的距离;P:出发点每升汽油价格;N:沿途油站数 第2n+1行,共n行,依次表示各个加油站信息,每行有两个数据: (第i+1行表示第i个油站,离出发点的距离Di;每升汽油价格Pi

输出共一行:表示最小费用,四舍五入至小数点后两位。 如果无法到达目的地,则输出“No Solution”

275.6 11.9 27.4 2.8 2 102.0 2.9 220.0 2.2

26.95

0

 

NOIP_1999.TG3:旅行家的预算

2017-03-18 12:03:24

1

64

N

3

4

0

1084

NOIP_1999.TG4:邮票面值设计

给定一个信封,最多只允许粘贴N张邮票, 计算在给定KN+K≤40)种邮票的情况下(假定所有的邮票数量都足够),如何设计邮票的面值,能得到最大值MAX,使在1MAX之间的每一个邮资值都能得到。 例如,N=3K=2,如果面值分别为1分、4分, 则在1分~6分之间的每一个邮资值都能得到(当然还有8分、9分和12分); 如果面值分别为1分、3分,则在1分~7分之间的每一个邮资值都能得到。 可以验证当N=3K=2时,7分就是可以得到的连续的邮资最大值,所以MAX=7,面值分别为1分、3分。

输入共一行: 两个数据NK。(其中,N表示至多粘贴N张邮标,K表示K种邮票)

输出共两行: 第一行为K个数据,依次表示采用的K种邮票面值。 第二行为连续的邮资最大值。

3 2

1 3 MAX=7

0

 

NOIP_1999.TG4:邮票面值设计

2017-03-18 12:03:24

1

64

N

2

5

0

1085

NOIP_2000.TG1:负进制转换

<p> <span style="line-height:1.5;">我们可以用这样的方式来表示一个十进制数: 将每个阿拉伯数字乘以一个以该数字所处位置的(值减1)为指数,以10为底数的幂之和的形式。</span> </p> <p> <span style="line-height:1.5;">例如:123可表示为 1*10^2+2*10^1+3*10^0这样的形式。 </span> </p> <p> <span style="line-height:1.5;"> 与之相似的,对二进制数来说,也可表示成每个二进制数码乘以一个以该数字所处位置的(值-1)为指数,以2为底数的幂之和的形式。一般说来,任何一个正整数R或一个负整数-R都可以被选来作为一个数制系统的基数。如果是以R或-R为基数,则需要用到的数码为 0,1,....R-1。例如,当R=7时,所需用到的数码是0,1,2,3,4,5和6,这与其是R或-R无关。如果作为基数的数绝对值超过10,则为了表示这些数码,通常使用英文字母来表示那些大于9的数码。例如对16进制数来说,用A表示10,用B表示11,用C表示12,用D表示13,用E表示14,用F表示15。 在负进制数中是用-R 作为基数,例如-15(十进制)相当于110001(-2进制),并且它可以被表示为2的幂级数的和数:110001=1*(-2)^5+1*(-2)^4+0*(-2)^3+0*(-2)^2+0*(-2)^1 +1*(-2)^0 设计一个程序,读入一个十进制数和一个负进制数的基数, 并将此十进制数转换为此负进制下的数: -R{-2,-3,-4,...,-20}</span> </p>

输入的每行有两个输入数据。 第一个是十进制数N(-32768<=N<=32767); 第二个是负进制数的基数-R。

<p> 结果显示在屏幕上,相对于输入,应输出此负进制数及其基数,若此基数超过10,则参照16进制的方式处理。 </p> <p> 数据在输出过程中,没有空格间隔。 </p>

30000 -2 -20000 -2 28800 -16 -25000 -16

30000=11011010101110000(base-2) -20000=1111011000100000(base-2) 28000=19180(base-16) -25000=7FB8(base-16)

0

 

NOIP_2000.TG1:负进制转换

2017-07-15 11:48:18

1

64

N

23

37

0

1086

NOIP_2000.TG2:乘积最大

今年是国际数学联盟确定的“2000——世界数学年,又恰逢我国著名数学家华罗庚先生诞辰90周年。在华罗庚先生的家乡江苏金坛,组织了一场别开生面的数学智力竞赛的活动,你的一个好朋友XZ也有幸得以参加。活动中,主持人给所有参加活动的选手出了这样一道题目: 设有一个长度为N的数字串,要求选手使用K个乘号将它分成K+1个部分,找出一种分法,使得这K+1个部分的乘积能够为最大。 同时,为了帮助选手能够正确理解题意,主持人还举了如下的一个例子: 有一个数字串:312, 当N=3K=1时会有以下两种分法: (1 3*12=36 2 31*2=62 这时,符合题目要求的结果是:31*2=62 现在,请你帮助你的好朋友XZ设计一个程序,求得正确的答案。

程序的输入共有两行: 第一行共有2个自然数NK6≤N≤401≤K≤6) 第二行是一个长度为N的数字串。

结果显示在屏幕上,相对于输入,应输出所求得的最大乘积(一个自然数)。

4 2 1231

62

0

 

NOIP_2000.TG2:乘积最大

2017-03-18 12:03:24

1

64

N

22

31

0

1087

NOIP_2000.TG3:单词接龙

单词接龙是一个与我们经常玩的成语接龙相类似的游戏,现在我们已知一组单词,且给定一个开头的字母,要求出以这个字母开头的最长的(每个单词都最多在中出现两次), 在两个单词相连时,其重合部分合为一部分, 例如 beastastonish,如果接成一条龙则变为beastonish,另外相邻的两部分不能存在包含关系,例如at  atide 间不能相连。

输入的第一行为一个单独的整数n (n<=20)表示单词数, 以下n 行每行有一个单词,输入的最后一行为一个单个字符,表示开头的字母。你可以假定以此字母开头的一定存在.

只需输出以此字母开头的最长的的长度

5 at touch cheat choose tact a

23 (连成的atoucheatactactouchoose

0

 

NOIP_2000.TG3:单词接龙

2017-03-18 12:03:24

1

64

N

14

22

0

1088

NOIP_2000.TG4:方格取数

<p> 设有N*N的方格图(N<=10,我们将其中的某些方格中填入正整数,而其他的方格中则放入数字0。 如下图所示(见样例): </p> <p> <img src="/JudgeOnline/upload/image/20180521/20180521165119_85691.png" alt="" /> </p> <p>     某人从图的左上角的A 点出发,可以向下行走,也可以向右走,直到到达右下角的B点。在走过的路上,他可以取走方格中的数(取走后的方格中将变为数字0)。 此人从A点到B 点共走两次,试找出2条这样的路径,使得取得的数之和为最大。 </p>

输入的第一行为一个整数N(表示N*N的方格图), 接下来的每行有三个整数: 前两个表示位置,第三个数为该位置上所放的数。 一行单独的0表示输入结束。

只需输出一个整数,表示2条路径上取得的最大的和。

8 2 3 13 2 6 6 3 5 7 4 4 14 5 2 21 5 6 4 6 3 15 7 2 14 0 0 0

67

0

NOIP_2000.TG4

NOIP_2000

2018-05-21 16:51:52

1

64

N

19

36

0

1089

NOIP_2001.TG1:一元三次方程求解

<p> 有形如:ax^3+bx^2+cx+d=0 这样的一个一元三次方程。 给出该方程中各项的系数(abcd 均为实数),并约定该方程存在三个不同实根(根的范围在-100100之间),且根与根之差的绝对值>=1。 要求由小到大依次在同一行输出这三个实根(根与根之间留有空格),并精确到小数点后2位。 </p> <p> <strong>提示:记方程f(x)=0,若存在2个数x1x2,且x1< x2f(x1)*f(x2)<0,则在(x1x2)之间一定有一个根。</strong> </p>

输入数据共一行:四个数据 abcd (abcd 均为实数)

输出数据共一行:三个数据。 由小到大依次在同一行输出这三个实根(根与根之间留有空格),并精确到小数点后2位。

1 -5 -4 20

-2.00 2.00 5.00

0

 

NOIP_2001.TG1:一元三次方程求解

2017-07-20 12:40:38

1

64

N

19

40

0

1090

NOIP_2001.TG2:数的划分

将整数n分成k份,且每份不能为空,任意两份不能相同(不考虑顺序)。 例如:n=7k=3,下面三种分法被认为是相同的。 115; 151; 511; 问有多少种不同的分法。

输入一行: nk  <span style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;line-height:16px;background-color:#FFFFFF;">(6<n<=2002<=k<=6)</span>

输出一行: 一个整数,即不同的分法。 样例1: 输出:4 {四种分法为:115;124;133;223;}

7 3

4 {四种分法为:115;124;133;223;}

0

 

NOIP_2001.TG2:数的划分

2017-05-29 15:55:39

1

64

N

40

51

0

1091

NOIP_2001.TG3:统计单词个数

<p style="font-family:"font-size:15px;vertical-align:baseline;color:#666666;"> 给出一个长度不超过200的由小写英文字母组成的字母串(约定;该字串以每行20个字母的方式输入,且保证每行一定为20)。要求将此字母串分成k(1< k<=40),且每份中包含的单词个数加起来总数最大(每份中包含的单词可以部分重叠。当选用一个单词之后,其第一个字母不能再用。例如字符串this中可包含thisis,选用this之后就不能包含th) </p> <p style="font-family:"font-size:15px;vertical-align:baseline;color:#666666;"> 单词在给出的一个不超过6个单词的字典中。 </p> <p style="font-family:"font-size:15px;vertical-align:baseline;color:#666666;"> 要求输出最大的个数。 </p>

<p style="font-family:"font-size:15px;vertical-align:baseline;color:#666666;"> 每组的第一行有二个正整数(pk) </p> <p style="font-family:"font-size:15px;vertical-align:baseline;color:#666666;"> p表示字串的行数; </p> <p style="font-family:"font-size:15px;vertical-align:baseline;color:#666666;"> k表示分为k个部分。 </p> <p style="font-family:"font-size:15px;vertical-align:baseline;color:#666666;"> 接下来的p行,每行均有20个字符。 </p> <p style="font-family:"font-size:15px;vertical-align:baseline;color:#666666;"> 再接下来有一个正整数s,表示字典中单词个数。(1<=s<=6) </p> <p style="font-family:"font-size:15px;vertical-align:baseline;color:#666666;"> 接下来的s行,每行均有一个单词。 </p>

<span style="color:#666666;font-family:"font-size:15px;">一个整数,分别对应每组测试数据的相应结果。</span>

输入: 1 3 thisisabookyouareaoh 4 is a ok sab

输出: //说明:(不必输出) 7 // this/isabookyoua/reaoh

0

 

NOIP_2001.TG3:统计单词个数

2017-07-19 18:51:39

1

64

N

4

11

0

1092

NOIP_2001.TG4:Car的旅行路线

<p> 又到暑假了,住在城市ACar想和朋友一起去城市B旅游。  </p> <p>  她知道每个城市都有四个飞机场,分别位于一个矩形的四个顶点上,同一个城市中两个机场之间有一条笔直的高速铁路,第I个城市中高速铁路了的单位里程价格为Ti,任意两个不同城市的机场之间均有航线,所有航线单位里程的价格均为t  </p> <p>   <img src="/JudgeOnline/upload/image/20170731/20170731203216_69349.png" alt="" /> </p> <p> 那么Car应如何安排到城市B的路线才能尽可能的节省花费呢? </p> <p> 她发现这并不是一个简单的问题,于是她来向你请教。  </p> <p> 任务 找出一条从城市AB的旅游路线,出发和到达城市中的机场可以任意选取,要求总的花费最少。  </p>

<p> 第一行为一个正整数n(0<=n<=10),表示有n组测试数据。 每组的第一行有四个正整数stAB <br /> <br /> S(0<S<=100)表示城市的个数,t表示飞机单位里程的价格,AB分别为城市AB的序号,(1<=AB<=S). </p> <p> 接下来有S行,其中第I行均有7个正整数xi1yi1xi2yi2xi3yi3Ti,这当中的(xi1yi1)(xi2yi2)(xi3yi3)分别是第I个城市中任意三个机场的坐标,T I为第I个城市高速铁路单位里程的价格。 </p> <p> <span style="color:#4F4F4F;font-family:"font-size:16px;background-color:#FFFFFF;"></span><br /> <span style="color:#4F4F4F;font-family:"font-size:16px;background-color:#FFFFFF;"></span> </p>

共有n行,每行一个数据对应测试数据。

输入 1 1 10 1 3 1 1 1 3 3 1 30 2 5 7 4 5 2 1 8 6 8 8 11 6 3

输出: 47.55

0

 

NOIP_2001

2018-05-27 16:49:57

1

64

N

5

9

0

2100

【苏州 NOId001: 问候

问候人类!

输入一行,一个名字,如 human(字符串类型,定义为 string

一行 ,输出 Hello human!(注意行尾的感叹号,且前面没有空格);

kitty

Hello kitty

0

 

 

2017-10-05 18:19:54

1

128

N

71

145

0

1093

【贪心】NOIP_2002.TG1:均分纸牌

<p>  N 堆纸牌,编号分别为 12…, N。每堆上有若干张,但纸牌总数必为 N 的倍数。 可以在任一堆上取若于张纸牌,然后移动。 </p> <p> 移牌规则为: 在编号为 1 堆上取的纸牌,只能移到编号为 2 的堆上; </p> <p> 在编号为 N 的堆上取的纸牌,只能移到编号为 N-1 的堆上; </p> <p> 其他堆上取的纸牌,可以移到相邻左边或右边的堆上。 </p> <p> 现在要求找出一种移动方法,用最少的移动次数使每堆上纸牌数都一样多。 </p> <p> 例如 N=44 堆纸牌数分别为:    9  8  17  6   移动3次可达到目的:   从  4 张牌放到 9 8 13 10 ->   3 张牌放到 9 11 10 10->   1 张牌放到10 10 10 10)。 </p>

输入数据为两行: 第一行:NN 堆纸牌,1 <= N <= 100) 第二行:A1 A2 … An N 堆纸牌,每堆纸牌初始数,l<= Ai <=10000

输出数据格式为单独一行:所有堆均达到相等时的最少移动次数。

4 9 8 17 6

3

0

 

NOIP_2002.TG1:均分纸牌

2017-05-29 14:14:36

1

64

N

38

87

0

1094

NOIP_2002.TG2:字串变换

已知有两个字串 A$, B$ 及一组字串变换的规则(至多6个规则):   A1$ -> B1$   A2$ -> B2$ 规则的含义为:在 A$中的子串 A1$ 可以变换为 B1$A2$ 可以变换为 B2$ …。   例如:A$'abcd' B$'xyz' 变换规则为:   ‘abc’->‘xu’ ‘ud’->‘y’ ‘y’->‘yz’ 则此时,A$ 可以经过一系列的变换变为 B$,其变换的过程为:   ‘abcd’->‘xud’->‘xy’->‘xyz’ 共进行了三次变换,使得 A$ 变换为B$

输入文件格式如下:   A$ B$   A1$ B1$ \   A2$ B2$ |-> 变换规则   ... ... / 所有字符串长度的上限为 20

输出文件格式如下:   若在 10 步(包含 10步)以内能将 A$ 变换为 B$ ,则输出最少的变换步数; 否则输出"NO ANSWER!"

abcd wyz abc xu ud y y yz

3

0

 

NOIP_2002.TG2:字串变换

2017-03-18 12:03:24

1

64

N

7

9

0

1095

NOIP_2002.TG3:自由落体

<p> 在高为 H 的天花板上有 n 个小球,体积不计,位置分别为 012n-1。在地面上有一个小车(长为 L,高为 K,距原点距离为 S1)。已知小球下落距离计算公式为 d1/2*g*(t^2),其中 g=10t 为下落时间。地面上的小车以速度 V 前进。 </p> <p> 如下图: <img src="/JudgeOnline/upload/image/20170720/20170720182049_21068.png" alt="" /> </p> <p>  小车与所有小球同时开始运动,当小球距小车的距离 <= 0.00001 时,即认为小球被小车接受(小球落到地面后不能被接受)。 请你计算出小车能接受到多少个小球。 </p>

文件输入格式: HS1VLKn l<=HS1VLKn <=100000

文件输出格式: 小车能接受到的小球个数。

5.0 9.0 5.0 2.5 1.8 5

1

0

 

NOIP_2002.TG3:自由落体

2017-07-20 18:20:55

1

64

N

13

22

0

1096

NOIP_2002.TG4:矩形覆盖

  在平面上有 n 个点(n <= 50),每个点用一对整数坐标表示。例如:当 n4 时,4个点的坐标分另为:p111),p222),p336),P407),见图一。 <img src="/JudgeOnline/upload/image/20170728/20170728213932_44017.png" alt="" /> 这些点可以用 k 个矩形(1<=k<=4)全部覆盖,矩形的边平行于坐标轴。 当 k=2 时,可用如图二的两个矩形 sls2 覆盖,s1s2 面积和为 4。 问题是当 n 个点坐标和 k 给出后,怎样才能使得覆盖所有点的 k 个矩形的面积之和为最小呢。 约定: 覆盖一个点的矩形面积为 0; 覆盖平行于坐标轴直线上点的矩形面积也为0。 各个矩形必须完全分开(边线与顶点也都不能重合)。

<p> 输人文件格式为:  </p> <p> 1行两个整数nk  </p> <p> 2~n+1 xi yi0<=xi,yi<=500) </p>

输出文件格式为: 一个整数,即满足条件的最小的矩形面积之和。

4 2 1 1 2 2 3 6 0 7

4

0

 

NOIP_2002.TG4:矩形覆盖

2017-07-28 21:42:14

1

64

N

6

6

0

1097

NOIP_2003.TG1:神经网络

<p> 【问题背景】 人工神经网络(Artificial Neural Network)是一种新兴的具有自我学习能力的计算系统,在模式识别、函数逼近及贷款风险评估等诸多领域有广泛的应用。对神经网络的研究一直是当今的热门方向,兰兰同学在自学了一本神经网络的入门书籍后,提出了一个简化模型,他希望你能帮助他用程序检验这个神经网络模型的实用性。 </p> <p> 【问题描述】 在兰兰的模型中,神经网络就是一张有向图,图中的节点称为神经元,而且两个神经 元之间至多有一条边相连,下图是一个神经元的例子:  <img src="/JudgeOnline/upload/image/20170720/20170720140806_31823.png" alt="" />图中,X1—X3是信息输入渠道,Y1Y2是信息输出渠道,C1表示神经元目前的状态, Ui是阈值,可视为神经元的一个内在参数。 神经元按一定的顺序排列,构成整个神经网络。在兰兰的模型之中,神经网络中的神 经无分为几层;称为输入层、输出层,和若干个中间层。每层神经元只向下一层的神经元 输出信息,只从上一层神经元接受信息。下图是一个简单的三层神经网络的例子。  兰兰规定,Ci服从公式:<img src="/JudgeOnline/upload/image/20170720/20170720140425_62451.jpg" alt="" />(其中n是网络中所有神经元的数目) 公式中的Wji(可能为负值)表示连接j号神经元和 i号神经元的边的权值。当 Ci大于0时,该神经元处于兴奋状态,否则就处于平静状态。当神经元处于兴奋状态时,下一秒 它会向其他神经元传送信号,信号的强度为Ci。 如此.在输入层神经元被激发之后,整个网络系统就在信息传输的推动下进行运作。 现在,给定一个神经网络,及当前输入层神经元的状态(Ci),要求你的程序运算出最后网 络输出层的状态。 </p>

输入文件格式: 第一行是两个整数n1≤n≤20)和p。 接下来n行,每行两个整数, 第i1行是神经元i最初状态和其阈值(Ui),非输入层的神经元开始时状态必然为0。 再下面P行,每行由两个整数ij及一个整数Wij,表示连接神经元ij的边权值为Wij

输出文件格式: 包含若干行,每行有两个整数,分别对应一个神经元的编号,及其最后的状态。 两个整数间以空格分隔。 仅输出最后状态非零的输出层神经元状态,并且按照编号由小到大顺序输出! 若输出层的神经元最后状态均为 0,则输出 NULL

5 6 1 0 1 0 0 1 0 1 0 1 1 3 1 1 4 1 1 5 1 2 3 1 2 4 1 2 5 1

3 1 4 1 5 1

0

 

NOIP_2003.TG1:神经网络

2017-07-20 15:13:33

1

64

N

6

12

0

1098

NOIP_2003.TG2:侦探推理

明明同学最近迷上了侦探漫画《柯南》并沉醉于推理游戏之中,于是他召集了一群同学玩推理游戏。 游戏的内容是这样的,明明的同学们先商量好由其中的一个人充当罪犯(在明明不知情的情况下),明明的任务就是找出这个罪犯。 接着,明明逐个询问每一个同学,被询问者可能会说: <img src="/JudgeOnline/upload/image/20170721/20170721082650_30727.gif" alt="" /> 证词中出现的其他话,都不列入逻辑推理的内容。 明明所知道的是,他的同学中有N个人始终说假话,其余的人始终说真。 现在,明明需要你帮助他从他同学的话中推断出谁是真正的凶手,请记住,凶手只有一个!

文件输入格式: 由若干行组成, 第一行有二个整数,M1≤M≤20)、N1≤N≤M)和P1≤P≤100); M是参加游戏的明明的同学数,N是其中始终说谎的人数,P是证言的总数。 接下来M行, 每行是明明的一个同学的名字(英文字母组成,没有主格,全部大写)。 往后有P行,每行开始是某个同学的名宇,紧跟着一个冒号和一个空格,后面是一句证词,符合前表中所列格式。 证词每行不会超过250个字符。 输入中不会出现连续的两个空格,而且每行开头和结尾也没有空格。

文件输出格式: 如果你的程序能确定谁是罪犯,则输出他的名字; 如果程序判断出不止一个人可能是罪犯,则输出 Cannot Determine; 如果程序判断出没有人可能成为罪犯,则输出 Impossible

3 1 5 MIKE CHARLES KATE MIKE:I am guilty. MIKE:Today is Sunday. CHARLES:MIKE is guilty KATE:I am guilty. KATE:How are you??

MIKE

0

 

NOIP_2003.TG2:侦探推理

2017-07-21 08:26:56

1

64

N

1

3

0

1099

NOIP_2003.TG3:加分二叉树

设一个n个节点的二叉树tree的中序遍历为(l,2,3,…,n),其中数字1,2,3,…,n为节点编号。 每个节点都有一个分数(均为正整数),记第j个节点的分数为ditree及它的每个子树都有一个加分,任一棵子树subtree(也包含tree本身)的加分计算方法如下: subtree的左子树的加分× subtree的右子树的加分+subtree的根的分数 若某个子树为主,规定其加分为1,叶子的加分就是叶节点本身的分数。不考虑它的空 子树。 试求一棵符合中序遍历为(1,2,3,…,n)且加分最高的二叉树tree。要求输出; (1tree的最高加分 (2tree的前序遍历

文件输入格式: 第1行:一个整数nn30),为节点个数。 第2行:n个用空格隔开的整数,为每个节点的分数(分数<100)。

文件输出格式: 第1行:一个整数,为最高加分(结果不会超过4,000,000,000)。 第2行:n个用空格隔开的整数,为该树的前序遍历。

5 5 7 1 2 10

145 3 1 2 4 5

0

 

NOIP_2003.TG3:加分二叉树

2017-03-18 12:03:24

1

64

N

3

7

0

1100

[搜索]NOIP_2003.TG4:传染病控制

<p> 近来,一种新的传染病肆虐全球。 </p> <p> 蓬莱国也发现了零星感染者,为防止该病在蓬莱国大范围流行,该国政府决定不惜一切代价控制传染病的蔓延。 </p> <p> 不幸的是,由于人们尚未完全认识这种传染病,难以准确判别病毒携带者,更没有研制出疫苗以保护易感人群。 </p> <p> 于是,蓬莱国的疾病控制中心决定采取切断传播途径的方法控制疾病传播。 </p> <p> 经过 WHO(世界卫生组织)以及全球各国科研部门的努力,这种新兴传染病的传播途径和控制方法已经研究消楚,剩下的任务就是由你协助蓬莱国疾控中心制定一个有效的控制办法。  </p> <p>  研究表明,这种传染病的传播具有两种很特殊的性质; 第一是它的传播途径是树型的,一个人X只可能被某个特定的人Y感染,只要Y不得病,或者是XY之间的传播途径被切断,则X就不会得病。  </p> <p>  第二是,这种疾病的传播有周期性,在一个疾病传播周期之内,传染病将只会感染一代患者,而不会再传播给下一代。 </p> <p>  这些性质大大减轻了蓬莱国疾病防控的压力,并且他们已经得到了国内部分易感人群的潜在传播途径图(一棵树)。但是,麻烦还没有结束。 </p> <p> 由于蓬莱国疾控中心人手不够,同时也缺乏强大的技术,以致他们在一个疾病传播周期内,只能设法切断一条传播途径,而没有被控制的传播途径就会引起更多的易感人群被感染(也就是与当前已经被感染的人有传播途径相连,且连接途径没有被切断的人群)。 </p> <p> 当不可能有健康人被感染时,疾病就中止传播。所以,蓬莱国疾控中心要制定出一个切断传播途径的顺序,以使尽量少的人被感染。 你的程序要针对给定的树,找出合适的切断顺序。 </p>

<p> 输入文件格式:  </p> <p> 输入格式的第一行是两个整数n1≤n≤300)和p  </p> <p> 接下来p行,每一行有两个整数ij, 表示节点ij间有边相连(意即,第i人和第j人之间有传播途径相连)。 </p> <p>  其中节点1是已经被感染的患者。 </p>

<p> 输出文件格式:  </p> <p> 只有一行,输出总共被感染的人数。 </p>

7 6 1 2 1 3 2 4 2 5 3 6 3 7

3

0

 

NOIP_2003

2018-05-26 14:38:00

1

64

N

4

7

0

1103

NOIP_2004.TG3:合唱队形

N位同学站成一排,音乐老师要请其中的(N-K)位同学出列,使得剩下的K位同学排成合唱队形。 合唱队形是指这样的一种队形:设K位同学从左到右依次编号为12…K,他们的身高分别为T1T2TK, 则他们的身高满足T1<...<Ti>Ti+1>…>TK(1<=i<=K)。 你的任务是,已知所有N位同学的身高,计算最少需要几位同学出列,可以使得剩下的同学排成合唱队形。

输入文件的第一行是一个整数N(2<=N<=100),表示同学的总数。 第二行有n个整数,用空格分隔,第i个整数Ti(130<=Ti<=230)是第i位同学的身高(厘米)

输出文件包括一行,这一行只包含一个整数,就是最少需要几位同学出列。

8 186 186 150 200 160 130 197 220

4

0

对于50%的数据,保证有n<=20; 对于全部的数据,保证有n<=100

NOIP_2004.TG3:合唱队形

2017-03-21 18:01:55

1

64

N

14

16

0

1104

NOIP_2004.TG4:虫食算

所谓虫食算,就是原先的算式中有一部分被虫子啃掉了,需要我们根据剩下的数字来判定被啃掉的字母。来看一个简单的例子:        43#9865#045     +    8468#6633        44445506978 其中#号代表被虫子啃掉的数字。根据算式,我们很容易判断:第一行的两个数字分别是53,第二行的数字是5。 现在,我们对问题做两个限制: 首先,我们只考虑加法的虫食算。这里的加法是N进制加法,算式中三个数都有N位,允许有前导的0。 其次,虫子把所有的数都啃光了,我们只知道哪些数字是相同的,我们将相同的数字用相同的字母表示,不同的数字用不同的字母表示。如果这个算式是N进制的,我们就取英文字母表午的前N个大写字母来表示这个算式中的0N-1N个不同的数字:但是这N个字母并不一定顺序地代表0N-1)。输入数据保证N个字母分别至少出现一次。          BADC     +    CRDA          DCCC 上面的算式是一个4进制的算式。很显然,我们只要让ABCD分别代表0123,便可以让这个式子成立了。你的任务是,对于给定的N进制加法算式,求出N个不同的字母分别代表的数字,使得该加法算式成立。输入数据保证有且仅有一组解。

输入文件包含4行。 第一行有一个正整数N(N<=26), 后面的3行每行有一个由大写字母组成的字符串,分别代表两个加数以及和。 这3个字符串左右两端都没有空格,从高位到低位,并且恰好有N位。

输出文件包含一行。 在这一行中,应当包含唯一的那组解。 解是这样表示的:输出N个数字,分别表示ABC……所代表的数字,相邻的两个数字用一个空格隔开,不能有多余的空格。

5 ABCED BDACE EBBAA

1 0 3 4 2

0

对于30%的数据,保证有N<10; 对于50%的数据,保证有N<15; 对于全部的数据,保证有N<26

NOIP_2004.TG4:虫食算

2017-03-21 18:01:55

1

64

N

0

2

0

1105

NOIP_2005.TG1:谁拿了最多奖学金

某校的惯例是在每学期的期末考试之后发放奖学金。发放的奖学金共有五种,获取的条件各自不同: (1) 院士奖学金,每人8000元,期末平均成绩高于80分(>80),并且在本学期内发表1篇或1篇以上论文的学生均可获得; (2) 五四奖学金,每人4000元,期末平均成绩高于85分(>85),并且班级评议成绩高于80分(>80)的学生均可获得; (3) 成绩优秀奖,每人2000元,期末平均成绩高于90分(>90)的学生均可获得; (4) 西部奖学金,每人1000元,期末平均成绩高于85分(>85)的西部省份学生均可获得; (5) 班级贡献奖,每人850元,班级评议成绩高于80分(>80)的学生干部均可获得; 只要符合条件就可以得奖,每项奖学金的获奖人数没有限制,每名学生也可以同时获得多项奖学金。例如姚林的期末平均成绩是87分,班级评议成绩82分,同时他还是一位学生干部,那么他可以同时获得五四奖学金和班级贡献奖,奖金总数是4850元。 现在给出若干学生的相关数据,请计算哪些同学获得的奖金总数最高(假设总有同学能满足获得奖学金的条件)。

输入文件的第一行是一个整数N1 <= N <= 100),表示学生的总数。 接下来的N行每行是一位学生的数据,从左向右依次是姓名,期末平均成绩,班级评议成绩,是否是学生干部,是否是西部省份学生,以及发表的论文数。 姓名是由大小写英文字母组成的长度不超过20的字符串(不含空格); 期末平均成绩和班级评议成绩都是0100之间的整数(包括0100); 是否是学生干部和是否是西部省份学生分别用一个字符表示,Y表示是,N表示不是; 发表的论文数是010的整数(包括010)。 每两个相邻数据项之间用一个空格分隔。

输出文件包括三行: 第一行是获得最多奖金的学生的姓名, 第二行是这名学生获得的奖金总数。如果有两位或两位以上的学生获得的奖金最多,输出他们之中在输入文件中出现最早的学生的姓名。第三行是这N个学生获得的奖学金的总数。

4 YaoLin 87 82 Y N 0 ChenRuiyi 88 78 N Y 1 LiXin 92 88 N N 0 ZhangQin 83 87 Y N 1

ChenRuiyi 9000 28700

0

 

NOIP_2005.TG1:谁拿了最多奖学金

2017-03-21 18:01:55

1

64

N

3

4

0

1106

NOIP_2005.TG2:过河

在河上有一座独木桥,一只青蛙想沿着独木桥从河的一侧跳到另一侧。在桥上有一些石子,青蛙很讨厌踩在这些石子上。由于桥的长度和青蛙一次跳过的距离都是正整数,我们可以把独木桥上青蛙可能到达的点看成数轴上的一串整点:01……L(其中L是桥的长度)。坐标为0的点表示桥的起点,坐标为L的点表示桥的终点。青蛙从桥的起点开始,不停的向终点方向跳跃。一次跳跃的距离是ST之间的任意正整数(包括S,T)。当青蛙跳到或跳过坐标为L的点时,就算青蛙已经跳出了独木桥。 题目给出独木桥的长度L,青蛙跳跃的距离范围S,T,桥上石子的位置。你的任务是确定青蛙要想过河,最少需要踩到的石子数。

输入文件: 第一行有一个正整数L1 <= L <= 10<sup>9</sup>),表示独木桥的长度。 第二行有三个正整数STM,分别表示青蛙一次跳跃的最小距离,最大距离,及桥上石子的个数, 其中1 <= S <= T <= 101 <= M <= 100。 第三行有M个不同的正整数分别表示这M个石子在数轴上的位置(数据保证桥的起点和终点处没有石子)。 所有相邻的整数之间用一个空格隔开。

输出文件只包括一个整数,表示青蛙过河最少需要踩到的石子数。

10 2 3 5 2 3 5 6 7

2

0

【数据规模】 对于30%的数据,L <= 10000; 对于全部的数据,L <= 10<sup>9</sup>

NOIP_2005.TG2:过河

2017-07-19 18:53:18

1

64

N

6

12

0

1107

NOIP_2005.TG3:篝火晚会

佳佳刚进高中,在军训的时候,由于佳佳吃苦耐劳,很快得到了教官的赏识,成为了小教官。在军训结束的那天晚上,佳佳被命令组织同学们进行篝火晚会。一共有n个同学,编号从1n。一开始,同学们按照12……n的顺序坐成一圈,而实际上每个人都有两个最希望相邻的同学。如何下命令调整同学的次序,形成新的一个圈,使之符合同学们的意愿,成为摆在佳佳面前的一大难题。 佳佳可向同学们下达命令,每一个命令的形式如下: (b1, b2,... bm -1, bm) 这里m的值是由佳佳决定的,每次命令m的值都可以不同。这个命令的作用是移动编号是b1b2…… bm –1bm的这m个同学的位置。要求b1换到b2的位置上,b2换到b3的位置上,……,要求bm换到b1的位置上。 执行每个命令都需要一些代价。我们假定如果一个命令要移动m个人的位置,那么这个命令的代价就是m。我们需要佳佳用最少的总代价实现同学们的意愿,你能帮助佳佳吗?

输入文件的第一行是一个整数n3 <= n <= 50000),表示一共有n个同学。 其后n行每行包括两个不同的正整数,以一个空格隔开, 分别表示编号是1的同学最希望相邻的两个同学的编号,编号是2的同学最希望相邻的两个同学的编号,……,编号是n的同学最希望相邻的两个同学的编号。

输出文件包括一行,这一行只包含一个整数,为最小的总代价。 如果无论怎么调整都不能符合每个同学的愿望,则输出-1

4 3 4 4 3 1 2 1 2

2

0

【数据规模】 对于30%的数据,n <= 1000; 对于全部的数据,n <= 50000

NOIP_2005.TG3:篝火晚会

2017-03-21 18:01:55

1

64

N

2

3

0

1108

【栈.7NOIP_2005.TG4:等价表达式

明明进了中学之后,学到了代数表达式。有一天,他碰到一个很麻烦的选择题。这个题目的题干中首先给出了一个代数表达式,然后列出了若干选项,每个选项也是一个代数表达式,题目的要求是判断选项中哪些代数表达式是和题干中的表达式等价的。 这个题目手算很麻烦,因为明明对计算机编程很感兴趣,所以他想是不是可以用计算机来解决这个问题。假设你是明明,能完成这个任务吗? 这个选择题中的每个表达式都满足下面的性质: 1. 表达式只可能包含一个变量‘a’ 2. 表达式中出现的数都是正整数,而且都小于10000 3. 表达式中可以包括四种运算‘+’(加),‘-’(减),‘*’(乘),‘^’(乘幂),以及小括号‘(’‘)’。小括号的优先级最高,其次是‘^’,然后是‘*’,最后是‘+’‘-’‘+’‘-’的优先级是相同的。相同优先级的运算从左到右进行。(注意:运算符‘+’‘-’‘*’‘^’以及小括号‘(’‘)’都是英文字符) 4. 幂指数只可能是110之间的正整数(包括110)。 5. 表达式内部,头部或者尾部都可能有一些多余的空格。 下面是一些合理的表达式的例子: ((a^1) ^ 2)^3a*a+a-a((a+a))9999+(a-a)*a1 + (a -1)^31^10^9……

输入文件格式: 第一行给出的是题干中的表达式。 第二行是一个整数n2 <= n <= 26),表示选项的个数。 后面n行,每行包括一个选项中的表达式。这n个选项的标号分别是ABCD…… 输入中的表达式的长度都不超过50个字符,而且保证选项中总有表达式和题干中的表达式是等价的。

输出文件包括一行: 这一行包括一系列选项的标号,表示哪些选项是和题干中的表达式等价的。 选项的标号按照字母顺序排列,而且之间没有空格。

( a + 1) ^2 3 (a-1)^2+4*a a + 1+ a a^2 + 2 * a * 1 + 1^2 + 10 -10 +a -a

AC

0

【数据规模】 对于30%的数据,表达式中只可能出现两种运算符‘+’‘-’; 对于其它的数据,四种运算符‘+’‘-’‘*’‘^’在表达式中都可能出现。 对于全部的数据,表达式中都可能出现小括号‘(’‘)’

NOIP_2005.TG4:等价表达式

2017-03-21 18:01:55

1

64

N

1

2

0

1109

NOIP_2006.TG1:能量项链

Mars星球上,每个Mars人都随身佩带着一串能量项链。在项链上有N颗能量珠。能量珠是一颗有头标记与尾标记的珠子,这些标记对应着某个正整数。并且,对于相邻的两颗珠子,前一颗珠子的尾标记一定等于后一颗珠子的头标记。因为只有这样,通过吸盘(吸盘是Mars人吸收能量的一种器官)的作用,这两颗珠子才能聚合成一颗珠子,同时释放出可以被吸盘吸收的能量。如果前一颗能量珠的头标记为m,尾标记为r,后一颗能量珠的头标记为r,尾标记为n,则聚合后释放的能量为(Mars单位),新产生的珠子的头标记为m,尾标记为n。 需要时,Mars人就用吸盘夹住相邻的两颗珠子,通过聚合得到能量,直到项链上只剩下一颗珠子为止。显然,不同的聚合顺序得到的总能量是不同的,请你设计一个聚合顺序,使一串项链释放出的总能量最大。 例如:设N=44颗珠子的头标记与尾标记依次为(23) (35) (510) (102)。我们用记号表示两颗珠子的聚合操作,(j⊕k)表示第jk两颗珠子聚合后所释放的能量。则第41两颗珠子聚合后释放的能量为: (4⊕1)=10*2*3=60。 这一串项链可以得到最优值的一个聚合顺序所释放的总能量为 ((4⊕1)⊕2)⊕3=10*2*3+10*3*5+10*5*10=710

输入文件格式: 第一行是一个正整数N4≤N≤100),表示项链上珠子的个数。 第二行是N个用空格隔开的正整数,所有的数均不超过1000。 第i个数为第i颗珠子的头标记(1≤i≤N), 当i<N< span>时,第i颗珠子的尾标记应该等于第i+1颗珠子的头标记。 第N颗珠子的尾标记应该等于第1颗珠子的头标记。 至于珠子的顺序,你可以这样确定: 将项链放到桌面上,不要出现交叉,随意指定第一颗珠子,然后按顺时针方向确定其他珠子的顺序。

输出文件格式: 只有一行,是一个正整数EE≤2.1*109),为一个最优聚合顺序所释放的总能量。

4 2 3 5 10

710

0

 

NOIP_2006.TG1:能量项链

2017-03-21 18:01:55

1

64

N

5

6

0

1110

NOIP_2006.TG2:金明的预算方案

金明今天很开心,家里购置的新房就要领钥匙了,新房里有一间金明自己专用的很宽敞的房间。更让他高兴的是,妈妈昨天对他说:你的房间需要购买哪些物品,怎么布置,你说了算,只要不超过N元钱就行。今天一早,金明就开始做预算了,他把想买的物品分为两类:主件与附件,附件是从属于某个主件的,下表就是一些主件与附件的例子: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1110.gif > 如果要买归类为附件的物品,必须先买该附件所属的主件。每个主件可以有0个、1个或2个附件。附件不再有从属于自己的附件。金明想买的东西很多,肯定会超过妈妈限定的N元。于是,他把每件物品规定了一个重要度,分为5等:用整数1~5表示,第5等最重要。他还从因特网上查到了每件物品的价格(都是10元的整数倍)。他希望在不超过N元(可以等于N元)的前提下,使每件物品的价格与重要度的乘积的总和最大。 设第j件物品的价格为v[j],重要度为w[j],共选中了k件物品,编号依次为j1j2……jk,则所求的总和为: v[j1]*w[j1]+v[j2]*w[j2]+ …+v[jk]*w[jk]。(其中*为乘号) 请你帮助金明设计一个满足要求的购物单。

输入文件格式: 第1行,为两个正整数,用一个空格隔开: n m(其中n<32000)表示总钱数,m<60为希望购买物品的个数。) 从第2行到第m+1行,第j行给出了编号为j-1的物品的基本数据,每行有3个非负整数 v p q 其中: v表示该物品的价格(v<10000), p表示该物品的重要度(1--5), q表示该物品是主件还是附件。 如果q=0,表示该物品为主件,如果q>0,表示该物品为附件,q是所属主件的编号。

输出文件只有一个正整数。 为不超过总钱数的物品的价格与重要度乘积的总和的最大值(<200000)。

1000 5 800 2 0 400 5 1 300 5 1 400 3 0 500 2 0

2200

0

 

NOIP_2006.TG2:金明的预算方案

2017-03-21 18:01:55

1

64

N

3

4

0

1111

NOIP_2006.TG3:作业调度方案

我们现在要利用m台机器加工n个工件,每个工件都有m道工序,每道工序都在不同的指定的机器上完成。每个工件的每道工序都有指定的加工时间。 每个工件的每个工序称为一个操作,我们用记号j-k表示一个操作,其中j1n中的某个数字,为工件号;k1m中的某个数字,为工序号,例如2-4表示第2个工件第4道工序的这个操作。在本题中,我们还给定对于各操作的一个安排顺序。 例如,当n=3m=2时,“1-11-22-13-13-22-2”就是一个给定的安排顺序,即先安排第1个工件的第1个工序,再安排第1个工件的第2个工序,然后再安排第2个工件的第1个工序,等等。 一方面,每个操作的安排都要满足以下的两个约束条件。 (1) 对同一个工件,每道工序必须在它前面的工序完成后才能开始; (2) 同一时刻每一台机器至多只能加工一个工件。 另一方面,在安排后面的操作时,不能改动前面已安排的操作的工作状态。 由于同一工件都是按工序的顺序安排的,因此,只按原顺序给出工件号,仍可得到同样的安排顺序,于是,在输入数据中,我们将这个安排顺序简写为“1 1 2 3 3 2”。 还要注意,安排顺序只要求按照给定的顺序安排每个操作。不一定是各机器上的实际操作顺序。在具体实施时,有可能排在后面的某个操作比前面的某个操作先完成。 例如,取n=3,m=2,已知数据如下: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1111.gif > 则对于安排顺序“1 1 2 3 3 2”,下图中的两个实施方案都是正确的。但所需要的总时间分别是1012。   当一个操作插入到某台机器的某个空档时(机器上最后的尚未安排操作的部分也可以看作一个空档),可以靠前插入,也可以靠后或居中插入。为了使问题简单一些,我们约定:在保证约束条件(1)(2)的条件下,尽量靠前插入。并且,我们还约定,如果有多个空档可以插入,就在保证约束条件(1)(2)的条件下,插入到最前面的一个空档。于是,在这些约定下,上例中的方案一是正确的,而方案二是不正确的。 显然,在这些约定下,对于给定的安排顺序,符合该安排顺序的实施方案是唯一的,请你计算出该方案完成全部任务所需的总时间。

输入文件格式: 第1行为两个正整数,用一个空格隔开: m n(其中m<20)表示机器数,n<20)表示工件数) 第2行:n个用空格隔开的数,为给定的安排顺序。 接下来的2n行,每行都是用空格隔开的m个正整数,每个数不超过20。 其中前n行依次表示每个工件的每个工序所使用的机器号,第1个数为第1个工序的机器号,第2个数为第2个工序机器号,等等。 后n行依次表示每个工件的每个工序的加工时间。 可以保证,以上各数据都是正确的,不必检验。

输出文件只有一个正整数,为最少的加工时间。

2 3 1 1 2 3 3 2 1 2 1 2 2 1 3 2 2 5 2 4

10

0

 

NOIP_2006.TG3:作业调度方案

2017-03-21 18:14:39

1

64

N

1

2

0

1112

NOIP_2006.TG4:2^K进制数

r是个2<sup>k</sup>进制数,并满足以下条件: (1r至少是个2位的2<sup>k</sup>进制数。 (2)作为2<sup>k</sup>进制数,除最后一位外,r的每一位严格小于它右边相邻的那一位。 (3)将r转换为2进制数q后,则q的总位数不超过w。 在这里,正整数k1≤k≤9)和wk<W< span>≤30000)是事先给定的。 问:满足上述条件的不同的r共有多少个? 我们再从另一角度作些解释:设S是长度为w 01字符串(即字符串Sw“0”“1”组成),S对应于上述条件(3)中的q。将S从右起划分为若干个长度为k 的段,每段对应一位2<sup>k</sup>进制的数,如果S至少可分成2段,则S所对应的二进制数又可以转换为上述的2<sup>k</sup>进制数r。 例:设k=3w=7。则r是个八进制数(23=8)。由于w=7,长度为701字符串按3位一段分,可分为3段(即133,左边第一段只有一个二进制位),则满足条件的八进制数有: 2位数:高位为16个(即121314151617),高位为25个,,高位为61个(即67)。共6+5+…+1=21个。 3位数:高位只能是1,第2位为25个(即123124125126127),第2位为34个,,第2位为61个(即167)。共5+4+…+1=15个。 所以,满足要求的r共有36个。

输入文件只有1行,为两个正整数,用一个空格隔开: k w

输出文件为1行,是一个正整数,为所求的计算结果,即满足条件的不同的r的个数(用十进制数表示), 要求最高位不得为0,各数字之间不得插入数字以外的其他字符(例如空格、换行符、逗号等)。 (提示:作为结果的正整数可能很大,但不会超过200位)

3 7

36

0

 

NOIP_2006.TG4:2<sup>k</sup>进制数

2017-03-21 18:14:39

1

64

N

0

2

0

1113

NOIP_2007.TG1:count统计数字

某次科研调查时得到了n个自然数,每个数均不超过15000000001.5*10<sup>9</sup>)。已知不相同的数不超过10000个,现在需要统计这些自然数各自出现的次数,并按照自然数从小到大的顺序输出统计结果。

输入文件包含n+1: 第一行是整数n,表示自然数的个数; 第2--n+1行,每行一个自然数。

输出文件包含m行(mn个自然数中不相同数的个数),按照自然数从小到大的顺序输出。 每行输出两个整数,分别是自然数和该数出现的次数,其间用一个空格隔开。

8 2 4 2 4 5 100 2 100

2 3 4 2 5 1 100 2

0

【限制】: 40%的数据满足:1<=n<=1000 80%的数据满足:1<=n<=50000 100%的数据满足:1<=n<=200000,每个数均不超过1500 000 0001.5*10<sup>9</sup>

NOIP_2007.TG1:count统计数字

2017-03-21 18:14:39

1

64

N

2

3

0

1114

NOIP_2007.TG2:expand字符串的展开

在初赛普及组的阅读程序写结果的问题中,我们曾给出一个字符串展开的例子:如果在输入的字符串中,含有类似于“d-h”或者“4-8”的字串,我们就把它当作一种简写,输出时,用连续递增的字母获数字串替代其中的减号,即,将上面两个子串分别输出为“defgh”“45678”。在本题中,我们通过增加一些参数的设置,使字符串的展开更为灵活。具体约定如下: (1) 遇到下面的情况需要做字符串的展开:在输入的字符串中,出现了减号“-”,减号两侧同为小写字母或同为数字,且按照ASCII码的顺序,减号右边的字符严格大于左边的字符。 (2) 参数p1:展开方式。p1=1时,对于字母子串,填充小写字母;p1=2时,对于字母子串,填充大写字母。这两种情况下数字子串的填充方式相同。p1=3时,不论是字母子串还是数字字串,都用与要填充的字母个数相同的星号“*”来填充。 (3) 参数p2:填充字符的重复个数。p2=k表示同一个字符要连续填充k个。例如,当p2=3时,子串“d-h”应扩展为“deeefffgggh”。减号两边的字符不变。 (4) 参数p3:是否改为逆序:p3=1表示维持原来顺序,p3=2表示采用逆序输出,注意这时候仍然不包括减号两端的字符。例如当p1=1p2=2p3=2时,子串“d-h”应扩展为“dggffeeh” (5) 如果减号右边的字符恰好是左边字符的后继,只删除中间的减号,例如:“d-e”应输出为“de”“3-4”应输出为“34”。如果减号右边的字符按照ASCII码的顺序小于或等于左边字符,输出时,要保留中间的减号,例如:“d-d”应输出为“d-d”“3-1”应输出为“3-1”

输入文件expand.in包括两行: 第1行为用空格隔开的3个正整数,一次表示参数p1p2p3。 第2行为一行字符串,仅由数字、小写字母和减号“-”组成。行首和行末均无空格。

输出文件expand.out只有一行,为展开后的字符串。

expand.in 【输入样例1】: 1 2 1 abcs-w1234-9s-4zz 【输入样例2】: 2 3 2 a-d-d 【输入样例3】: 3 4 2 di-jkstra2-6

expand.out 【输出样例1】: abcsttuuvvw1234556677889s-4zz 【输出样例2】: aCCCBBBd-d 【输出样例3】: dijkstra2************6

0

【限制】: 40%的数据满足:字符串长度不超过5 100%的数据满足:1<=p1<=31<=p2<=81<=p3<=2。字符串长度不超过100

NOIP_2007.TG2:expand字符串的展开

2017-03-21 18:14:39

1

64

N

0

2

0

1115

NOIP_2007.TG3:game矩阵取数游戏

帅帅经常更同学玩一个矩阵取数游戏:对于一个给定的n*m的矩阵,矩阵中的每个元素aij据为非负整数。游戏规则如下: 1. 每次取数时须从每行各取走一个元素,共n个。m次后取完矩阵所有的元素; 2. 每次取走的各个元素只能是该元素所在行的行首或行尾; 3. 每次取数都有一个得分值,为每行取数的得分之和;每行取数的得分 = 被取走的元素值*2i,其中i表示第i次取数(从1开始编号); 4. 游戏结束总得分为m次取数得分之和。 帅帅想请你帮忙写一个程序,对于任意矩阵,可以求出取数后的最大得分。

输入文件game.in包括n+1行; 第一行为两个用空格隔开的整数nm。 第2--n+1行为n*m矩阵,其中每行有m个用单个空格隔开

输出文件game.out仅包含1行,为一个整数,即输入矩阵取数后的最大的分。

game1.in 2 3 1 2 3 3 4 2 【输入输出样例1解释】 第1次:第一行取行首元素,第二行取行尾元素,本次的氛围1*21+2*21=6 2次:两行均取行首元素,本次得分为2*22+3*22=20 3次:得分为3*23+4*23=56。总得分为6+20+56=82 game2.in 1 4 4 5 0 5 game3.in 2 10 96 56 54 46 86 12 23 88 80 43 16 95 18 29 30 53 88 83 64 67

game1.out 82 game2.out 122 game3.out 316994

0

【限制】: 60%的数据满足:1<=n, m<=30,答案不超过10<sup>16</sup> 100%的数据满足:1<=n, m<=800<=aij<=1000

NOIP_2007.TG3:game矩阵取数游戏

2017-03-21 18:14:39

2

64

N

0

2

0

1116

NOIP_2007.TG4:core树网的核

T=(V, E, W) 是一个无圈且连通的无向图(也称为无根树),每条边到有正整数的权,我们称T为树网(treebetwork),其中VE分别表示结点与边的集合,W表示各边长度的集合,并设Tn个结点。 路径:树网中任何两结点ab都存在唯一的一条简单路径,用d(a, b)表示以a, b为端点的路径的长度,它是该路径上各边长度之和。我们称d(a, b)a, b两结点间的距离。 D(v, P)=min{d(v, u), u为路径P上的结点}。 树网的直径:树网中最长的路径成为树网的直径。对于给定的树网T,直径不一定是唯一的,但可以证明:各直径的中点(不一定恰好是某个结点,可能在某条边的内部)是唯一的,我们称该点为树网的中心。 偏心距ECC(F):树网T中距路径F最远的结点到路径F的距离,即 ECC(F)=max{d(v, F)v∈V} 任务:对于给定的树网T=(V, E, W)和非负整数s,求一个路径F,他是某直径上的一段路径(该路径两端均为树网中的结点),其长度不超过s(可以等于s),使偏心距ECC(F)最小。我们称这个路径为树网T=(V, E, W)的核(Core)。必要时,F可以退化为某个结点。一般来说,在上述定义下,核不一定只有一个,但最小偏心距是唯一的。 下面的图给出了树网的一个实例。图中,A-BA-C是两条直径,长度均为20。点W是树网的中心,EF边的长度为5。如果指定s=11,则树网的核为路径DEFG(也可以取为路径DEF),偏心距为8。如果指定s=0(或s=1s=2),则树网的核为结点F,偏心距为12 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1116.gif>

输入文件core.in包含n行: 第1行,两个正整数ns,中间用一个空格隔开。 其中n为树网结点的个数,s为树网的核的长度的上界。设结点编号以此为12……n。 从第2行到第n行, 每行给出3个用空格隔开的正整数,依次表示每一条边的两个端点编号和长度。 例如,“2 4 7”表示连接结点24的边的长度为7。 所给的数据都是正确的,不必检验。

输出文件core.out只有一个非负整数,为指定意义下的最小偏心距。

core1.in 5 2 1 2 5 2 3 2 2 4 4 2 5 3 core2.in 8 6 1 3 2 2 3 2 3 4 6 4 5 3 4 6 4 4 7 2 7 8 3

core1.out 5 core2.out 5

0

【限制】 40%的数据满足:5<=n<=15 70%的数据满足:5<=n<=80 100%的数据满足:5<=n<=3000<=s<=1000。边长度为不超过1000的正整数

NOIP_2007.TG4:core树网的核

2017-03-21 18:14:39

1

64

N

0

3

0

1117

冬令营_2004.1:twins孪生项链

佳佳有许多黑色和白色的小珠子,他最喜欢用它们穿成一串串漂亮的项链了。他的每条项链都是由不超过n个小珠子串在一起的环(称项链上的珠子数为项链的长度),每条项链至少有一个珠子。每做完一条项链就在其中的某一个珠子上贴一个标签,从贴有标签的那颗珠子开始, 顺时针记录每个珠子的颜色(白色用0表示,黑色用1表示)。标签上写着这种记录。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1117.gif> 佳佳发现,这样做,每条项链都可以用多个标签来表示,例如图(a)的项链,当标签分别贴在珠子1234的时候,标签上应分别写作0100100000010010。在这样的情况下,佳佳总是选择字典序最小的一个串写在标签上。例如图(a)的项链, 在珠子3处帖上标签0001。 再考虑图(b)所示的项链,最小字典序的标签串是0101,可是标签应该贴在哪颗珠子上呢?珠子1上还是珠子3上呢?佳佳不希望出现这样的情况。所以他在做项链的时候格外小心,保证做出来的项链是合法的(也就是不会出现标签位置不唯一的情况)。 这样,标签上的记录就可以标识一个串。根据标签上串的字典序就可以对项链进行排序,例如图(c)的项链比图(d)的小,因为00101的字典序比0011小。 任务一:新年快到了,佳佳决定给自己的两个双胞胎表妹一人做一条项链。刚做完其中一条项链后,佳佳突然有了一个绝妙的想法:既然是送给孪生姐妹,为什么不做一对孪生项链呢?换句话说,如果把所有可能的项链排好顺序,孪生项链的位置应当是相邻的,姐姐的项链标签的字典序要比妹妹的大。佳佳想把已经做好的一条项链送给妹妹,那么姐姐的项链应该是什么样子的呢? 任务二:佳佳还想知道所有合法的项链中长度恰好为k的有多少条,你能告诉他吗?

输入文件twins.in的第1行包含三个整数nmk(1<=m, k<=n),相邻整数用一个空格隔开, 其中n表示每条项链的珠子数上限;m表示任务一中妹妹的项链长度; k表示任务二中的项链长度。 第2行包括一个长度为m01串,表示妹妹的项链上的标签。输入数据保证无误。

输出文件twins.out的第1行有一个正整数t,表示长度恰好为k的项链有t条; 第2行包括一个01串,表示姐姐的项链上的标签。 输入数据保证姐姐的项链一定可以做出来。

twins.in 5 5 5 00101

twins.out 6 0011

0

【评分方法】 仅第一行正确,得40%的分数 仅第二行正确,得60%的分数 两行都正确,得100%的分数 【数据规模】 n的范围: 20%的数据:1<=n<=10 40%的数据:1<=n<=100 70%的数据:1<=n<=1000 100%的数据:1<=n<=200,000 k的范围: 30%的数据:1<=k<=10 60%的数据:1<=k<=50 100%的数据:1<=k<=1000 【样例解释】 项链可能有以下14种: 0, 00001, 0001, 00011, 001, 00101, 0011, 00111, 01, 01011, 011, 0111, 01111, 1 其中长度为1, 2, 3, 4, 5的项链分别有2, 1, 2, 3, 6个。

冬令营_2004.1:twins孪生项链

2017-03-21 18:14:39

1

64

N

0

0

0

1118

冬令营_2004.2:remover搬家公司

你率领着巨人组成的搬家公司为大富翁搬家。你拥有n个巨人,依次标号为12n,巨人i只能搬动i吨或者更轻的重物。大富翁有n件家具需要搬运,也依次标号为12n,重为i吨的家具恰有一件。显然,当每个巨人i恰好被要求去搬运i吨的家具时,搬家工作才能顺利展开。很不幸的是,你没有称量器械,也无法从家具的外表辨别出它们的重量。你唯一能做的就是发布指令,要求巨人Ai搬运第i号家具,使得一个巨人恰搬运一件家具。 1)如果巨人i搬运的家具小于i吨,那么它会将家具举过头顶;如果巨人i搬运的家具恰为i吨,那么它会将家具拎至腰间;如果巨人i搬运的家具超过i吨,那么它只能把家具放在地上了。 2)如果每个巨人都把家具拎至腰间,那么测试成功,搬家工作顺利展开;否则,根据巨人的表现,你可以决定并发布下一次测试指令。 3)需要特别注意:为了不惹恼大富翁,你最多只有20次发布测试指令的机会。 【交互】 本题是一道交互式题目,测试库提供两个函数:StartTest,作用如下: 1Start必须最先调用且只能调用一次,用它来开始搬家工作并获得整数 n2)首先将指令写入某数组A,表示接下来你希望巨人Ai去搬运第i号家具;然后调用过程TestTest会根据巨人的表现修改数组AAi=–1表示第i号家具被巨人举过头顶,Ai=0表示第i号家具被巨人拎至腰间,Ai=1表示第i号家具被巨人放在地上。如果成功,测试库将正常退出,切记你的程序不得自行终止。 下表列出了PascalC/C++程序员使用测试库的方法。其中TA为库中预定义好的数据类型,它是一个整数数组。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1118a.gif > 【如何测试你的程序】 1)建立文件remover.in。文件的第1行包含一个数n,即重物的个数,第2行包含n个整数,分别表示n件重物的重量。这些数应该为整数1--n的一个排列。 2)运行你的程序。 3)运行结束后,测试库会把测试结果输出到remover.out中,它包含你的程序调用Test过程的次数(如果程序正常终止),或者相应的错误信息(异常终止)。 【一个成功交互的例子】 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1118b.gif >

 

 

-2 -3 3 1 2 3

 

0

【评分方法】 如果你的程序有下列情况之一,得0分,其他情况得满分: (1)访问了任何文件(包括临时文件)或者自行终止; (2)让测试库异常退出; (3)第20次调用Test后仍然有家具被巨人放在地上。 【数据规模】 30%的数据:1<=n<=10 60%的数据:1<=n<=100 100%的数据:1<=n<=1000

冬令营_2004.2:remover搬家公司

2017-03-21 18:14:39

1

64

N

0

2

0

1119

冬令营_2004.3:airpig会飞的小猪

天哪,我们家的猪怎么飞起来了!佳佳看到自家上空飘着的一头头小猪,呆呆的站在那里,怎么样才能把它们弄回各自的圈中呢?佳佳,起床啦!听到妈妈的声音,佳佳眼前一亮,一下子从床上坐了起来。原来刚才是在做梦。好神奇啊……”佳佳吃早饭的时候还在回味着,如果梦里的情景真的出现了,不是很有趣吗?佳佳顾不得吃完早饭,立刻找来一张纸,趴在桌子上开始画了起来。 佳佳画了一个n×n的方格地图,代表猪圈上空被分成nn列,从上到下依次为第0, 1, 2... n-1行,从左到右依次为第0, 1, 2... n-1列。同时处于第x行和第y列的方格记为格子(x, y)。佳佳在其中m个格子里各画了一个星号“*”,表示那些格子就是猪圈,而在另外m个格子里各画了一只不同运动方向的小猪,我们从上到下从左到右把这些小猪编号为0, 1, 2, 3...m-1。换句话说,设两只初始位置分别为(x1,y1)(x2,y2)的小猪的编号分别为l1l2,则l1<l2当且仅当①x1<x2;或者②x1=x2并且y1<y2。佳佳定义了小猪运动方向的数字表示,数字5表示不动,数字2表示向南,4向西,6向东,8向北运动。每一时刻,小猪都会沿着各自的运动方向行进一格,除非它已落进猪圈。如果在地图边界的小猪向地图外的方向前进一格之后被视作又回到了相对的边界。比如,在右边界上朝东运动的小猪经过一个时刻之后会进入左边界的格子中。为便于理解,处在格子(x, y)的小猪下一时刻的位置如下表所示。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1119a.gif> 佳佳希望自己能够控制小猪们的行动,因此设计了五种吹气操作,每个时间单位执行一次,每次执行可以改变一行或者一列中所有小猪的运动方向,五种操作如下表所示: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1119b.gif> 请注意,后四种吹气操作都只改变运动方向,而不会影响到小猪的位置。 小猪的运动是以秒为单位的,初始时刻为0。每秒初佳佳先进行吹气操作,改变一些(也可能是0个)小猪的运动方向,然后所有小猪按照表1的方式运动。如果在下一时刻会有多只猪运动到某一猪圈,让其中编号最小的一只进圈。其他猪仍可进入该格,但不视为进圈。换句话说,编号最小的那只猪和圈同时消失。这是因为一个圈只能容纳一只小猪,因此在有小猪落入其中以后,我们可以认为该猪圈和那只小猪一起消失。 编号为i的小猪进圈的时刻记为ti (i=1,2,…n)T¬1=Max{ti}T2=∑ti。佳佳的目标就是让T2尽量小。佳佳知道这个任务很困难,所以他会根据你的T2和目前已知最好的T2的相对优劣程度给你奖励。

输入文件airpig1.inairpig10.in已经放在用户目录中, 文件第一行为测试数据编号caseN。 第二行仅有一个整数n,为地图的大小。 以下n行每行n个字符,描述整个地图。字符“.”表示空地,“*”表示猪圈, 字符52468分别表示天上小猪的运动方向, 5是不动,2是向南运动,4是向西、6是向东、8是向北运动。

本题是一道提交答案式的题目。 你应当提供十个输出文件airpig1.outairpig10.out,放在用户目录中。 每个文件的第一行为测试数据编号caseN,这个数应该和输入文件保持一致。 第二行有两个整数T1T2T1表示最后一只猪的入圈时刻,T2表示所有猪入圈时刻的总和。 以下T1行每行有一个字符串,表示每个时刻进行的吹气操作。吹气操作的输出格式见表2

airpig.in 1 5 ...*. ..5.. ..5.. *.... ..... 【样例解释】 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1119c.gif>

airpig.out 1 4 7 E2 E1 N3 S0

0

【评分标准】 对于每个测试点,如果你的输出不正确,得0分,否则你的得分按下式计算: score = [目前已知最优输出 / 你的输出* 9] + 1。 其中[x]表示不超过x的最大整数。 【你如何测试自己的输出】 输出测试程序check放在用户目录下。使用方法为: check <测试点编号X>。程序会自动读取输入文件airpigX.in和你的输出文件airpigX.out,其中X=1,2,…,10。程序会在屏幕上输出你的结果是否正确。

冬令营_2004.3:airpig会飞的小猪

2017-03-21 18:14:39

1

64

N

0

0

0

1120

冬令营_2005.1:species友好的生物

W星球是一个和地球一样气候适宜、物种聚集的星球。经过多年的研究,外星生物学家们已经发现了数万种生物,而且这个数字还在不断增大。 W星球上的生物很有趣,有些生物之间很友好,朝夕相伴,形影不离;但有些却很敌对,一见面就难免发生战斗。为了能够更好地了解它们之间的友好程度,外星生物学家希望进行一些量化的计算。他们发现,两种生物之间的友好程度和它们的K种属性有关,暂且将它们编号为属性1、属性2……、属性K,这些属性都是可以进行量化的。外星生物学家研究发现,如果前K-1种属性的差别越大,这两种生物就越友好;但是属性K与众不同,这种属性差别越小的两种生物越友好。 因此他们猜想是不是可以用这样一个公式量化两种生物之间的友好程度: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1120a.gif> 如果知道了每种生物的各种属性,利用上述公式就很容易算出它们之间的友好程度了。现在,外星生物学家们想问一问:在目前发现的这些生物当中,关系最友好的那对生物是哪一对呢?它们之间的友好程度是多少?

输入文件的第一行是两个整数NK,分别表示目前发现的生物种数和属性的种数。 第二行有K个非负整数Ci,即计算友好程度时所需的常数。 接下来的N行,描述每种生物,按照先后顺序依次编号为生物1、生物2……、生物N。每一行都有K个整数,给出该种生物的各项属性值,按照先后顺序依次编号为属性1、属性2……、属性K

输出文件包含两行。 第一行为两个整数iji ≠ j),表示你所找到的关系最友好的两种生物为生物i和生物j。若最友好的不止一对,输出任意一对。 第二行为一个整数,表示生物i和生物j之间的友好程度。

5 3 1 2 3 -5 3 2 -2 3 0 0 5 9 3 4 -1 -10 -11 7

3 5 36 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1120b.gif>

0

【约定】  2 ≤ N ≤ 100,000  2 ≤ K ≤ 5  0 ≤ Ci ≤ 100 每种生物的各项属性值不小于-10000且不大于10000  最大的友好程度一定大于0

冬令营_2005.1:species友好的生物

2017-03-21 18:14:39

1

64

N

0

0

0

1121

冬令营_2005.2:dface双面棋盘

佳佳有一个nn列的黑白棋盘,每个格子都有两面,一面白色,一面黑色。佳佳把棋盘平放在桌子上,因此每个格子恰好一面朝上,如下图所示: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1121a.gif> 我们把每行从上到下编号为123……n,各列从左到右编号为123……n,则每个格子可以用棋盘坐标(x, y)表示。在上图中,有8个格子黑色朝上,另外17个格子白色朝上。 如果两个同色格子有一条公共边,我们称这两个同色格子属于同一个连通块。上图共有5个黑色连通块和3个白色连通块。 佳佳可以每分钟将一个格子翻转(即白色变成黑色,黑色变成白色),然后计算当前有多少个黑色连通块和白色连通块,你能算得更快吗?

输入文件的第一行包含一个正整数n,为格子的边长。 以下n行每行n个整数,非01,表示初始状态。0表示白色,1表示黑色。 下一行包含一个整数m,表示操作的数目。以下m行每行两个整数x, y (1 ≤ x, y ≤ n),表示把坐标为(x, y)的格子翻转。

输出文件包含m行,每行对应一个操作。 该行包括两个整数b, w,表示黑色区域和白色区域数目。 【约定】  1 ≤ n ≤ 200  1 ≤ m ≤ 10,000

5 0 1 0 0 0 0 1 1 1 0 1 0 0 0 1 0 0 1 0 0 1 0 0 0 0 2 3 2 2 3

4 3 5 2 【样例说明】 翻转(3, 2)之后,棋盘变为: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1121b.gif> 4个黑色区域和3个白色区域 翻转(2, 3)之后,棋盘变为: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1121c.gif> 5个黑色区域和2个白色区域

0

 

冬令营_2005.2:dface双面棋盘

2017-03-21 19:32:57

1

64

N

0

0

0

1122

冬令营_2005.3:corn蜂窝玉米

蜂窝玉米是一道湖南名菜,也是岳岳和佳佳的最爱。既然名叫蜂窝玉米,这道菜自然由很多颗玉米粒组成,两颗玉米粒之间可以用一根可食用的线连接。他们观察发现,如果把玉米粒看作点,把线看成边的话,每盘蜂窝玉米恰好构成一棵树。他们还发现,饭馆用来装蜂窝玉米的盘子一般是正方形的,如果适当地建立平面直角坐标系,玉米粒均放在整点(横坐标和纵坐标都是整数的点)上,连接玉米粒的线都被拉直且不相交。 回家后不久就要过年了,岳岳和佳佳想为朋友们表演一下自己的厨艺——做一盆色香味俱全的蜂窝玉米。但是问题来了,要一个多大的正方形盘子才能够装下这道菜呢?

输入文件corn*.in第一行为玉米粒的颗数n, 以下n-1行每行包含两个整数uv,表示玉米粒uv连有一条线。

输出文件corn*.out包含n行,依次表示玉米粒1,2,3...n的坐标, 用两个非负整数x, y表示。按照题意,正方形盘子的边长就等于 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1122a.gif>

4 1 2 2 3 2 4

0 1 0 0 1 0 1 1

0

【评分方法】 对于每个测试点,如果你的输出非法,得0分,否则至少得1分,具体计算公式如下: 假设参考解的边长为Best,你的边长为Ans,则你的得分为: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1122b.gif> 【如何测试你的输出】 你可以使用checker程序检查你的输出,格式为: checker TestNo 其中TestNo为测试点编号。例如你已经得到了数据5的输出corn5.out,可以使用命令 checker 5 来测试你的输出是否合法。执行此命令时corn5.incorn5.out必须存在。 【特别提示】 请妥善保存输入文件*.in和你的输出*.out,及时备份,以免误删。

冬令营_2005.3:corn蜂窝玉米

2017-03-21 19:32:57

1

64

N

0

0

0

1123

【培训教程.模拟题】打保龄球

打保龄球是用一个滚球去打击十个站立的柱,将柱击倒。一局分十轮,每轮可滚球一次或多次,以击倒的柱数为依据计分。一局得分为十轮得分之和,而每轮的得分不仅与本轮滚球情况有关,还可能与后续一两轮的滚球情况有关。即某轮某次滚球击倒的柱数不仅要计入本轮得分,还可能会计入前一两轮得分。具体的滚球击柱规则和计分方法如下: (1)若某一轮的第一次滚球就击倒全部十个柱,则本轮不再滚球(若是第十轮则还需 另加两次滚球,不妨称其为第十一轮和第十二轮,并不是所有的情况都需要滚第十一轮和第十二轮球)。该轮得分为本次击倒柱数10与以后两次滚球所击倒柱数之和。 (2)若某一轮的第一次滚球未击倒十个柱,则可对剩下未倒的柱再滚球一次。如果这 两次滚球击倒全部十个柱,则本轮不再滚球(若是第十轮则还需另加一次滚球),该轮得分 为这两次共击倒柱数10与以后一次滚球所击倒柱数之和。 (3)若某一轮两次滚球未击倒全部十个柱,则本轮不再继续滚球,该轮得分为这两次 滚球击倒的柱数之和。 总之,若轮中一次滚球或两次滚球击倒十个柱,则本轮得分是本轮首次滚球开始的 连续三次滚球击倒柱数之和(其中有一次或两次不是本轮滚球)。若一轮内二次滚球击倒柱 数不足十个,则本轮得分即为这两次击倒柱数之和。下面以实例说明如下(字符“/”表示击倒当前球道上的全部的柱): 轮 1 2 3 4 5 6 7 8 9 10 11 12 击球情况 / / / 72 9/ 81 8/ / 9/ / 8/ 各轮得分 30 27 19 9 18 9 20 20 20 20 累计总分 30 57 76 85 103 112 132 152 172 192 现在请你编写一个保龄球实时计分程序,用来计算和显示某轮结束后的得分情况。若某轮的得分暂时无法算出,则该轮得分不显示。

输入数据用文件bowling.in, 文件内容仅有一行,为前若干轮滚球的情况,每轮滚球用一到两个字符表示,每一个字符表示一次击球,字符“/”表示击倒当前球道上的全部的柱,否则用一个数字字符表示本次滚球击倒的当前球道上的柱的数目,两轮滚球之间用一个空格字符隔开。 如上例对应的输入文件内容为:/ / / 72 9/ 81 8/ / 9/ / 8/

输出到文件bowling.out,共两行, 第一行为每轮得分, 第二行为到当前轮为止的总得分。每个得分之间用一个空格隔开。

/ / / 72 9/ 81 8/ / 9/ / 8/

30 27 19 9 18 9 20 20 20 20 30 57 76 85 103 112 132 152 172 192

0

 

【培训教程.模拟题】打保龄球

2017-03-21 19:32:57

1

64

N

0

2

0

1124

【培训教程.模拟题】EVAC安全逃离

农夫john最近在研究如果发生重大事故,如何让农场里的奶牛逃离问题。他想要确信在紧急情况下,所有的奶牛都有一个安全逃离方案。因为在紧急情况下,奶牛们都会失去观察和判断能力,所以最近john一直在教奶牛们逃离的方法,他的方法很简单,就是任何时候都只向北方或东方逃离,北方是行坐标减1的方向,东方是列坐标加1的方向。奶牛们虽笨,不过这一点事关自己的生命,所以他们牢记在心,而且也一定会这么做。 当然也会出问题,奶牛们在逃离的方向上会横冲直撞,为了阻止奶牛之间互相冲撞造成伤害,john要求任何一个奶牛的逃离路线不能经过其它奶牛的初始位置。一个逃离方案是安全的如果它能够满足上面的要求,反之它就是不安全的。 奶牛们所在的土地(农场)被划分成了r行和c列的一个矩形地图。奶牛们都待在这个矩形中的某一个位置。 请帮助john确定给定的一个地图上是否存在一个安全的逃离方案。 比如,下面的两个图: 左边的例子表示了一个能够安全逃离的地图,因为没有任何一个奶牛的逃离路线上包括其他奶牛。右边的例子表示了一个不安全的地图,因为位于(4,1)的奶牛不论是向东逃离还是向北逃离,它的路线上都会有别的奶牛,从这个图中拿掉任意一头奶牛,这个地图都会变成安全的。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1124.gif>

1行:两个整数r,c,用1个空格隔开,表示矩形的行数和列数(均不超过50)。 第2行:一个整数n,表示奶牛的个数(不超过100)。 第3n+2行:共n行,每行有两个整数,之间用1个空格隔开,分别表示这头奶牛所在的行和列。

如果这块土地是安全的,输出0。 如果移走任意一头奶牛这块土地还是不安全,输出-1。 否则输出1,并且在下一行输出移走的那头奶牛的编号,如果有多个奶牛满足要求,输出输入序列中编号最小一个。

EVAC.IN 5 5 5 1 1 2 4 3 1 2 2 2 1

EVAC.OUT 1 5

0

 

【培训教程.模拟题】EVAC安全逃离

2017-03-21 19:32:57

1

64

N

0

1

0

1125

【培训教程.模拟题】express表达式的转换

平常我们书写的表达式称为中缀表达式,因为它将运算符放在两个操作数中间,许多情况下为了确定运算顺序,括号是不可少的,而中缀表达式就不必用括号了。 后缀标记法:书写表达式时采用运算紧跟在两个操作数之后,从而实现了无括号处理和优先级处理,使计算机的处理规则简化为:从左到右顺序完成计算,并用结果取而代之。 例如:8–(3+2*6)/5+4可以写为:8 3 2 6*+5/–4+ 其计算步骤为:8 3 2 6 * + 5 / – 4 + 8 3 12 + 5 / – 4 + 8 15 5 / – 4 + 8 3 – 4 + 5 4 + 9 编写一个程序,完成这个转换,要求输出的每一个数据间都留一个空格。

就一行,是一个后缀表达式。 输入的符号中只有这些基本符号“0123456789+-*/^()”,并且不会出现形如2*-3的格式。 表达式中的基本数字也都是一位的,不会出现形如12形式的数字。 所输入的字符串不要判错。

若干个中缀表达式,第I+1行比第I行少一个运算符和一个操作数,最后一行只有一个数字,表示运算结果。 运算的结果可能为负数,“/”以整除运算。并且中间每一步都不会超过2<sup>31</sup>

express .in 8–(3+2*6)/5+4

express .out 8 3 2 6 * + 5 / – 4 + 8 3 12 + 5 / – 4 + 8 15 5 / – 4 + 8 3 – 4 + 5 4 + 9

0

 

【培训教程.模拟题】express表达式的转换

2017-03-21 19:32:57

1

64

N

0

2

0

1126

【培训教程.模拟题】HEAVEN到天宫做客

有一天,我做了个梦,梦见我很荣幸的接到了猪八戒的邀请,到天宫陪他吃酒。我犹豫了。天上一日,人间一年啊!当然,我是个闲人,一年之中也没有多少时日是必须在人间的,因此,我希望选一个最长的空闲时间段,使我在天上待的时间尽量长。记住,今年是4000年。天上一天也是24小时,每小时60分,每分60秒。

输入文件的第一行是一个非负整数 N,表示4000年中必须呆在人间的天数, 以下共N行,每行两个用空格隔开的正整数,即日期(月,日),输入文件保证无错误,日期无重复。

输出文件仅有一行包含一个非负整数,即在天上的时间(四舍五入精确到秒)

heaven.in 2 3 8 12 2

heaven.out 63266

0

 

【培训教程.模拟题】HEAVEN到天宫做客

2017-03-21 19:32:57

1

64

N

0

2

0

1127

【培训教程.模拟题】BED奶牛卧室

奶牛们有一个习惯,那就是根据自己的编号选择床号。如果一头奶牛编号是a,并且有0..k-1一共k张床,那么她就会选择a mod k号床作为她睡觉的地点。显然,2头牛不能睡在一张床上。那么给出一些奶牛的编号,请你为她们准备一间卧室,使得里面的床的个数最少。

第一行是奶牛的个数n(1<=n<=5000); 第2到第n+1行是每头奶牛的编号Si(1<=Si<=1000000)

仅一行,是最少的床的数目。

BED.IN 5 4 6 9 10 13

BED.OUT 8

0

 

【培训教程.模拟题】BED奶牛卧室

2017-03-21 19:32:57

2

64

N

0

2

0

1128

【培训教程.模拟题】change进制转换

请你编一程序实现两种不同进制之间的数据转换。

输入数据共有三行, 第一行是一个正整数,表示需要转换的数的进制n(2≤n≤16), 第二行是一个n进制数,若n>10则用大写字母AF表示数码1015,并且该n进制数对应的十进制的值不超过1000000000, 第三行也是一个正整数,表示转换之后的数的进制m(2≤m≤16)

输出仅一行,包含一个正整数,表示转换之后的m进制数。

change.in 16 FF 2

change.out 11111111

0

 

【培训教程.模拟题】change进制转换

2017-03-21 19:32:57

1

64

N

0

2

0

1129

【培训教程.模拟题】coin硬币翻转

在桌面上有一排硬币,共N枚,每一枚硬币均为正面朝上。现在要把所有的硬币翻转成反面朝上,规则是每次可翻转任意N-1枚硬币(正面向上的被翻转为反面向上,反之亦然)。求一个最短的操作序列(将每次翻转N-1枚硬币成为一次操作)。

输入只有一行,包含一个自然数NN为不大于100的偶数)。

输出文件的第一行包含一个整数S,表示最少需要的操作次数。接下来的S行每行分别表示每次操作后桌上硬币的状态(一行包含N个整数(01),表示每个硬币的状态:0——正面向上,和1——反面向上,不允许出现多余空格)。 对于有多种操作方案的情况,则只需输出一种。

coin.in 4

coin.out 4 0111 1100 0001 1111

0

 

【培训教程.模拟题】coin硬币翻转

2017-03-21 19:32:57

1

64

N

0

2

0

1130

【培训教程.模拟题】HEART拱猪计分

拱猪是一种很有趣的扑克牌游戏。 即使你不知道它的玩法,你也可以由它的计分方式来了解它的趣味性。 假设在此我们仅考虑四个人的拱猪牌局,本题要求你根据下面的计分规则,在牌局结束时计算四位玩家所得分数。 1. 我们分别以 SHD  C 来代表黑桃,红心,方块及梅花,并以数字 1  13 来代表 A2QK 等牌点,例如︰ H1 为红心 AS13 为黑桃 K 2. 牌局结束时,由各玩家持有的有关计分的牌(计分牌)仅有 S12 (),所有红心牌,D11 () C10 (加倍)16张牌。其它牌均弃置不计。若未持有这 16 张牌之任一张则以得零分计算。 3. 若持有 C10 的玩家只有该张牌而没有任何其它牌则得 +50 分,若除了 C10 还有其它计分牌,则将其它计分牌所得分数加倍计算。 4. 若红心牌不在同一家,则 H1  H13  13 张牌均以负分计,其数值为 -50-2-3-4-5-6-7-8-9-10-20-30-40。而且 S12  D11 分别以 -100  +100 分计算。 5. 若红心牌 H1 H13 均在同一家,有下列情形︰ o 所有红心牌以+200分计算。 o  S12D11 皆在吃下所有红心牌之一家,则此玩家得 +500 分。 o  C10 还是以前面所述原则计算之。 例一:若各玩家持有计分牌如下:(每列代表一玩家所持有之牌) S12 H3 H5 H13 D11 H8 H9 C10 H1 H2 H4 H6 H7 H10 H11 H12 则各家之得分依序为:-148+83-138  -60。 例二:若各玩家持有计分牌如下:(第四家未持有任何计分牌) H1 H2 H3 H4 H5 H6 H7 H8 H9 H10 H11 H12 H13 S12 C10 D11 则各家之得分依序为:+200-200+100  0。 例三:若有一玩家持有所有 16 张计分牌,则得 +1000 分。其余三家均得零分。

每个输入文件由多组测试数据构成,每组测试数据有四行, 每一行第一个数为该玩家所持有计分牌总数, 而后列出其所持有之所有计分牌, 牌数与各计分牌均以一个以上的空格分开。 相邻两组测试数据之间不会有空白行, 读到四家持牌数都为 0 表示文件结束。

每一行输出一组测试数据对应的结果,依次输出各家所得分数,共四个整数(含正负号,0 除外), 相邻两个整数之间以一个空格分开,符号和数字间不可以有空格。每组输出间不需要有空白行。

HEART.IN 4 S12 H3 H5 H13 3 D11 H8 H9 6 C10 H1 H2 H4 H6 H7 3 H10 H11 H12 13 H1 H2 H3 H4 H5 H6 H7 H8 H9 H10 H11 H12 H13 2 S12 C10 1 D11 0 0 0 0 0

HEART.OUT -148 +83 -138 -60 +200 -200 +100 0

0

 

【培训教程.模拟题】HEART拱猪计分

2017-03-21 19:32:57

1

64

N

0

3

0

1131

【培训教程.模拟题】carry车厢重组

在一个旧式的火车站旁边有一座桥,其桥面可以绕河中心的桥墩水平旋转。一个车站的职工发现桥的长度最多能容纳两节车厢,如果将桥旋转180度,则可以把相邻两节车厢的位置交换,用这种方法可以重新排列车厢的顺序。于是他就负责用这座桥将进站的车厢按车厢号从小到大排列。他退休后,火车站决定将这一工作自动化,其中一项重要的工作是编一个程序,输入初始的车厢顺序,计算最少用多少步就能将车厢排序。

输入文件有两行数据, 第一行是车厢总数N(不大于10000), 第二行是N个不同的数表示初始的车厢顺序。

一个数据,是最少的旋转次数。

carry .in 4 4 3 2 1

carry .out 6

0

 

【培训教程.模拟题】carry车厢重组

2017-03-21 20:48:41

1

64

N

0

3

0

1132

【培训教程.模拟题】fact阶乘问题

也许你早就知道阶乘的含义,N阶乘是由1N相乘而产生,如: 12! = 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8 x 9 x 10 x 11 x 12 = 479,001,600 12的阶乘最右边的非零位为6。 写一个程序,计算N(1<=N<=50,000,000)阶乘的最右边的非零位的值。 注意:10,000,000!有2499999个零。

仅一行包含一个正整数N

单独一行包含一个整数表示最右边的非零位的值。

fact.in 12

fact.out 6

0

 

【培训教程.模拟题】fact阶乘问题

2017-03-21 20:48:41

6

64

N

0

2

0

1133

【培训教程.模拟题】num子数整数

对于一个五位数a1a2a3a4a5,可将其拆分为三个子数: sub1=a1a2a3 sub2=a2a3a4 sub3=a3a4a5 例如,五位数20207可以拆分成 sub1=202 sub2=020=20 sub3=207 现在给定一个正整数K,要求你编程求出1000030000之间所有满足下述条件的五位数,条件是这些五位数的三个子数sub1sub2sub3都可被K整除。

输入由键盘输入,输入仅一行,为正整数K0<K<1000)。

输出到文件,输出文件的每一行为一个满足条件的五位数,要求从小到大输出。不得重复输出或遗漏。 如果无解,则输出“No”

num.in 15

num.out 22555 25555 28555 30000

0

 

【培训教程.模拟题】num子数整数

2017-03-21 20:48:41

1

64

N

0

3

0

1134

【培训教程.模拟题】WELL垃圾陷阱

卡门——农夫约翰极其珍视的一条Holsteins奶牛——已经落了到垃圾井中。垃圾井是农夫们扔垃圾的地方,它的深度为D (2 <= D <= 100)英尺。 卡门想把垃圾堆起来,等到堆得与井同样高时,她就能逃出井外了。另外,卡门可以通过吃一些垃圾来维持自己的生命。 每个垃圾都可以用来吃或堆放,并且堆放垃圾不用花费卡门的时间。 假设卡门预先知道了每个垃圾扔下的时间t(0<t<=1000),以及每个垃圾堆放的高度h(1<=h<=25)和吃进该垃圾能维持生命的时间f(1<=f<=30),要求出卡门最早能逃出井外的时间,假设卡门当前体内有足够持续10小时的能量,如果卡门10小时内没有进食,卡门就将饿死。

第一行为2个整数,D  G (1 <= G <= 100)G为被投入井的垃圾的数量。 第二到第G+1行每行包括3个整数: T (0 < T <= 1000),表示垃圾被投进井中的时间; F (1 <= F <= 30),表示该垃圾能维持卡门生命的时间; 和 H (1 <= H <= 25),该垃圾能垫高的高度。

如果卡门可以爬出陷阱,输出一个整表示最早什么时候可以爬出; 否则输出卡门最长可以存活多长时间。

WELL.IN 20 4 5 4 9 9 3 2 12 6 10 13 1 1

WELL.OUT 13

0

[样例说明] 卡门堆放她收到的第一个垃圾:height=9; 卡门吃掉她收到的第二个垃圾,使她的生命从10小时延伸到13小时; 卡门堆放第3个垃圾,height=19; 卡门堆放第4个垃圾,height=20

【培训教程.模拟题】WELL垃圾陷阱

2017-03-21 20:48:41

1

64

N

0

1

0

1135

【培训教程.模拟题】BUYLOW低价购买

低价购买这条建议是在奶牛股票市场取得成功的一半规则。要想被认为是伟大的投资者,你必须遵循以下的问题建议:“低价购买;再低价购买。每次你购买一支股票,你必须用低于你上次购买它的价格购买它。买的次数越多越好!你的目标是在遵循以上建议的前提下,求你最多能购买股票的次数。你将被给出一段时间内一支股票每天的出售价(2<sup>16</sup>范围内的正整数),你可以选择在哪些天购买这支股票。每次购买都必须遵循低价购买;再低价购买的原则。写一个程序计算最大购买次数。 这里是某支股票的价格清单: 日期 1 2 3 4 5 6 7 8 9 10 11 12 价格 68 69 54 64 68 64 70 67 78 62 98 87 最优秀的投资者可以购买最多4次股票,可行方案中的一种是: 日期 2 5 6 10 价格 69 68 64 62

1: N (1 <= N <= 5000),股票发行天数 第2: N个数,是每天的股票价格。

输出文件仅一行包含两个数:最大购买次数和拥有最大购买次数的方案数(<=2<sup>31</sup>) 当二种方案看起来一样时(就是说它们构成的价格队列一样的时候),2种方案被认为是相同的。

BUYLOW.IN 12 68 69 54 64 68 64 70 67 78 62 98 87

BUYLOW.OUT 4 2

0

 

【培训教程.模拟题】BUYLOW低价购买

2017-03-21 20:48:41

1

64

N

0

2

0

1136

【培训教程.模拟题】game棋盘游戏

在一个4*4的棋盘上有8个黑棋和8个白棋,当且仅当两个格子有公共边,这两个格子上的棋是相邻的。移动棋子的规则是交换相邻两个棋子。现在给出一个初始棋盘和一个最终棋盘,要求你找出一个最短的移动序列使初始棋盘变为最终棋盘。 Klux说:这么简单的题目,我都会做!

14行每行四个数字(1或者0),描述了初始棋盘 接着是一个空行 第69行每行四个数字,描述了最终棋盘

输出文件的第一行是一个整数n,表示最少的移动步数。 接下来n行每行4个数,r1,c1,r2,c2,表示移动的两个棋子的坐标(r1,c1),(r2,c2) (棋盘左上角的坐标为(1,1),并且他右边的格子为(1,2)) 如果有许多组解,你可以输出任意一组。

game.in: 1111 0000 1110 0010 1010 0101 1010 0101

game.out 4 1 2 2 2 1 4 2 4 3 2 4 2 4 3 4 4

0

说明: 翻译自ceoi99-game,数据及解答由ceoi提供。

【培训教程.模拟题】game棋盘游戏

2017-03-21 20:48:41

2

64

N

0

0

0

1137

【培训教程.模拟题】INT求正整数

对于任意输入的正整数n,请编程求出具有n个不同因子的最小正整数m。 例如:n=4,则m=6,因为64个不同整数因子1236;而且是最小的有4个因子的整数。

n1≤n≤50000

m

INT.IN 4

INT.OUT 6

0

 

【培训教程.模拟题】INT求正整数

2017-03-21 20:48:41

2

64

N

0

1

0

1138

【培训教程.模拟题】LIFT奇怪的电梯

呵呵,有一天我做了一个梦,梦见了一种很奇怪的电梯。 大楼的每一层楼都可以停电梯,而且第i层楼(1<=i<=N)上有一个数字Ki(0<=Ki<=N)。 电梯只有四个按钮:开,关,上,下。上下的层数等于当前楼层上的那个数字。 当然,如果不能满足要求,相应的按钮就会失灵。 例如:3 3 1 2 5代表了Ki(K1=3,K2=3,……), 从一楼开始。在一楼,按可以到4楼,按是不起作用的,因为没有-2楼。那么,从A楼到B楼至少要按几次按钮呢?

输入文件共有二行, 第一行为三个用空格隔开的正整数,表示N,A,B(1≤N≤200, 1≤A,B≤N), 第二行为N个用空格隔开的正整数,表示Ki

输出文件仅一行,即最少按键次数, 若无法到达,则输出-1

LIFT.IN 5 1 5 3 3 1 2 5

LIFT.OUT 3

0

 

【培训教程.模拟题】LIFT奇怪的电梯

2017-03-21 20:48:41

1

64

N

1

2

0

1139

【培训教程.模拟题】BOMB轰炸

我该怎么办?飞行员klux向你求助。 事实上,klux面对的是一个很简单的问题,但是他实在太菜了。 klux要想轰炸某个区域内的一些地方,它们是位于平面上的一些点,但是(显然地)klux遇到了抵抗,所以klux只能飞一次,而且由于飞机比较破,一点起飞就只能沿直线飞行,无法转弯。现在他想一次轰炸最多的地方。

输入数据由n对整数组成(1<n<700), 每对整数表示一个点的坐标。没有一个点会出现两次。

一个整数,表示一条直线能覆盖的最多的点数。

bomb.in 1 1 2 2 3 3 9 10 10 11

bomb.out 3

0

说明: 本题翻译并改编自uva270,数据及解答由uva提供。

【培训教程.模拟题】BOMB轰炸

2017-03-21 20:48:41

2

64

N

1

2

0

1140

【培训教程.模拟题】combo连续自然数和

对一个给定的自然数M,求出所有的连续的自然数段,这些连续的自然数段中的全部数之和为M。 例子:1998+1999+2000+2001+2002 = 10000,所以从19982002的一个自然数段为M=10000的一个解。

包含一个整数的单独一行给出M的值(10 <= M <= 2,000,000)。

每行两个自然数,给出一个满足条件的连续自然数段中的第一个数和最后一个数, 两数之间用一个空格隔开,所有输出行的第一个按从小到大的升序排列, 对于给定的输入数据,保证至少有一个解。

combo.in 10000

combo.out 18 142 297 328 388 412 1998 2002

0

 

【培训教程.模拟题】combo连续自然数和

2017-03-21 20:48:41

1

64

N

3

3

0

1141

【培训教程.模拟题】joseph约瑟夫

n个人站成一圈,从某个人开始数数,每次数到m的人就被杀掉,然后下一个人重新开始数,直到最后只剩一个人。 现在有一圈人,k个好人站在一起,k个坏人站在一起。从第一个好人开始数数。 你要确定一个最小的m,使得在第一个好人被杀死前,k个坏人先被杀死。

一个k0<k<14

一个m

joseph1.in 3 joseph2.in 4

joseph1.out 5 joseph2.out 30

0

说明: 翻译自uva305,数据及解答由uva提供。

【培训教程.模拟题】joseph约瑟夫

2017-03-21 21:06:24

2

64

N

0

3

0

1142

【培训教程.模拟题】LINES点和线

平面上有一些点,你可以用直线将两点连接起来。那么有多少种方法可以把这些点连续地连起来,使得任何两个线都不交叉。 显然,三个点只有一种方法。四个点最多只有3种方法。写一个程序计算方法总数。

每一行是一个点的坐标,坐标值是整数,中间用一个空格隔开。 最后一个坐标是原点。 任意三点不在一条直线上。最多只有10个点。

输出,方案总数。

LINES.IN 100 -10 -200 0 45 7 0 0

LINES.OUT 3

0

 

【培训教程.模拟题】LINES点和线

2017-03-21 21:06:41

1

64

N

0

1

0

1143

【培训教程.模拟题】CHORE杂务

John的农场在给奶牛挤奶前有很多杂务要完成,每一项杂务都需要一定的时间来完成它。 比如:他们要将奶牛集合起来,将他们赶进牛棚,为奶牛清洗乳房以及一些其它工作。尽早将所有杂务完成是必要的,因为这样才有更多时间挤出更多的牛奶。 当然,有些杂务必须在另一些杂务完成的情况下才能进行。比如:只有将奶牛赶进牛棚才能开始为它清洗乳房,还有在未给奶牛清洗乳房之前不能挤奶。我们把这些工作称为完成本项工作的准备工作。至少有一项杂务不要求有准备工作,这个可以最早着手完成的工作,标记为杂务1 John有需要完成的n个杂务的清单,并且这份清单是有一定顺序的,杂务k(k>1)的准备工作只可能在杂务1..k-1中。 写一个程序从1n读入每个杂务的工作说明。计算出所有杂务都被完成的最短时间。当然互相没有关系的杂务可以同时工作,并且,你可以假定John的农场有足够多的工人来同时完成任意多项任务。

1行:一个整数n,必须完成的杂务的数目(3<=n<=10,000); 第2 ~ n+1行: 共有n行,每行有一些用1个空格隔开的整数,分别表示: * 工作序号(1..n,在输入文件中是有序的) * 完成工作所需要的时间len1<=len<=100); * 一些必须完成的准备工作,总数不超过100个,由一个数字0结束。有些杂务没有需要准备的工作只描述一个单独的0,整个输入文件中不会出现多余的空格。

一个整数,表示完成所有杂务所需的最短时间。

CHORE.IN 7 1 5 0 2 2 1 0 3 3 2 0 4 6 1 0 5 1 2 4 0 6 8 2 4 0 7 4 3 5 6 0

CHORE.OUT 23

0

 

【培训教程.模拟题】CHORE杂务

2017-03-21 21:06:57

1

64

N

0

1

0

1144

【培训教程.模拟题】LIST排行榜

小迈克尔住在一个小镇上,他喜欢看每周日下午发布的音乐电视评比。它每周都根据选票介绍相同的歌曲,列出这些歌曲的流行排行榜。<br /> <br />      有一个星期日迈克尔和他的朋友在一起玩得太久了以致于未能看到新的流行榜。他非常失望,但是不久他就发现下周至少可以部分地建立出流行榜。除了每首歌曲的位置,排行榜还根据这些歌曲上周的排行列出了它们排行变动的信息,更精确地说,从这周起,不管那首歌是继续排在原位,还是排名上升或排名下降,都会给出一点说明。<br /> <br />     编写程序,根据给定的流行榜帮助迈克尔推断出上周可能的排行榜。<br />

输入文件的第一行是一个整数N1≤N≤100,表示排行榜上歌曲的总数。<br /> <br /> 接下来的N块列出了排行信息。<br /> <br /> 每块有两行组成,<br /> <br /> i块第一行是第i首歌曲的名称,歌名包括最多不超过100个英文大写字母,<br /> <br /> 第二行包含下列三个单词中的一个:UP(歌曲在排行榜上的位置上升)DOWN(歌曲在排行榜上的位置下滑)SAME(排行不变),表示与上周排行榜相比,排行榜所发生的变动。

输出文件应该用N行输出一个上周可能的排行榜。<br /> <br /> 每一行包含一首歌名,即第i行包含排行榜上第i首歌的歌名。<br /> <br /> 注意:解不必是唯一的,但对于每一个测试数据都至少有一个解。<br />

5 HIGHHOPES UP LOWFEELINGS UP UPANDDOWN DOWN IAMSTILLSTANDING DOWN FOOLINGAROUND DOWN

UPANDDOWN IAMSTILLSTANDING FOOLINGAROUND HGHHOPES LOWFEELINGS

0

 

 

2017-03-21 21:12:48

1

128

N

0

2

0

1145

【培训教程.模拟题】LOAN银行贷款

当一个人从银行贷款后,在一段时间内他()将不得不每月偿还固定的分期付款。 这个问题要求计算出贷款者向银行支付的利率。假设利率按月累计。

输入文件仅一行包含三个用空格隔开的正整数。 第一个整数表示贷款的原值, 第二个整数表示每月支付的分期付款金额, 第三个整数表示分期付款还清贷款所需的总月数。

输出文件应该是一个实数,表示该贷款的月利率(用百分数表示),四舍五入精确到0.1%

LOAN.IN 1000 100 12

LOAN.OUT 2.9

0

 

【培训教程.模拟题】LOAN银行贷款

2017-03-21 21:13:35

1

64

N

0

2

0

1146

【培训教程.模拟题】ROBOT机器人搬重物

机器人移动学会(RMI)现在正尝试用机器人搬运物品。 机器人的形状是一个直径1.6米的球。在试验阶段,机器人被用于在一个储藏室中搬运货物。 储藏室是一个N*M的网格,有些格子为不可移动的障碍。 机器人的中心总是在格点上,当然,机器人必须在最短的时间内把物品搬运到指定的地方。 机器人接受的指令有: 先前移动1步(Creep); 向前移动2步(Walk); 向前移动3步(Run); 向左转(Left); 向右转(Right)。 每个指令所需要的时间为1秒。请你计算一下机器人完成任务所需的最少时间。

输入的第一行为两个正整数N,MN,M<=50), 下面N行是储藏室的构造,0表示无障碍,1表示有障碍,数字之间用一个空格隔开。 接着一行有四个整数和一个大写字母,分别为起始点和目标点左上角网格的行与列, 起始时的面对方向(东E,南S,西W,北N),数与数,数与字母之间均用一个空格隔开。 终点的面向方向是任意的。

一个整数,表示机器人完成任务所需的最少时间。 如果无法到达,输出-1 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1146.gif>

ROBOT.IN 9 10 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 7 2 2 7 S

ROBOT.OUT 12

0

 

【培训教程.模拟题】ROBOT机器人搬重物

2017-03-21 21:13:41

1

64

N

0

3

0

1147

【培训教程.模拟题】compages数字组合

N个数中找出其和为M的若干个数。 先读入正整数N1<N<100)和M(1<M<10000), 再读入N个正数(可以有相同的数字,每个数字均在1000以内), 在这N个数中找出若干个数, 使它们的和是M, 把满足条件的数字组合都找出来以统计组合的个数,输出组合的个数(不考虑组合是否相同)。要求你的程序运行时间不超过1秒。

第一行是两个数字,表示NM。 第二行起是N个数。

就一个数字,表示和为M的组合的个数。

compages.in 4 4 1 1 2 2

compages.out 3

0

 

【培训教程.模拟题】compages数字组合

2017-03-21 21:13:41

10

64

N

0

1

0

1148

【培训教程.模拟题】GENE相似基因

大家都知道,基因可以看作一个碱基对序列。它包含了4种核苷酸,简记作A,C,G,T。生物学家正致力于寻找人类基因的功能,以利用于诊断疾病和发明药物。 在一个人类基因工作组的任务中,生物学家研究的是:两个基因的相似程度。因为这个研究对疾病的治疗有着非同寻常的作用。两个基因的相似度的计算方法如下: 对于两个已知基因,例如AGTGATGGTTAG,将它们的碱基互相对应。当然,中间可以加入一些空碱基-,例如: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1148a.gif > 这样,两个基因之间的相似度就可以用碱基之间相似度的总和来描述,碱基之间的相似度如下表所示: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1148b.gif > 那么相似度就是:(-3)+5+5+(-2)+(-3)+5+(-3)+5=9。因为两个基因的对应方法不唯一,例如又有: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1148c.gif > 相似度为:(-3)+5+5+(-2)+5+(-1)+5=14。规定两个基因的相似度为所有对应方法中,相似度最大的那个。

共两行。 每行首先是一个整数,表示基因的长度; 隔一个空格后是一个基因序列,序列中只含A,C,G,T四个字母。1<=序列的长度<=100

仅一行,即输入基因的相似度。

GENE.IN 7 AGTGATG 5 GTTAG

GENE.OUT 14

0

 

【培训教程.模拟题】GENE相似基因

2017-03-21 21:13:41

1

64

N

0

1

0

1149

【培训教程.模拟题】NUM波浪数

波浪数是在一对数字之间交替转换的数,如1212121,双重波浪数则是指在两种进制下都是波浪数的数,如十进制数191919是一个十进制下的波浪数,它对应的十一进制数121212也是一个波浪数,所以十进制数191919是一个双重波浪数。 类似的可以定义三重波浪数,三重波浪数在三种不同的进制中都是波浪数,甚至还有四重波浪数,如十进制300=606(七进制)=363(九进制)=454(八进制)=1A1(十三进制), 你的任务就是在指定范围内找出双重、三重、四重波浪数。

单独一行包含五个用空格隔开的十进制整数, 前两个数表示进制的范围(2••32), 第三与第四个数表示指定的范围(1••10000000), 第五个数为2,3,4中的一个,表示要找的波浪数的重数。

从小到大以十进制形式输出指定范围内的指定重数的波浪数。 一行输出一个数。

NUM.IN 10 11 190000 960000 2

NUM.OUT 191919 383838 575757 767676 959595

0

 

【培训教程.模拟题】NUM波浪数

2017-03-21 21:13:41

15

64

N

0

2

0

1150

【培训教程.模拟题】ZIP文件压缩

提高文件的压缩率一直是人们追求的目标。近几年有人提出了这样一种算法,它虽然只是单纯地对文件进行重排,本身并不压缩文件,但是经这种算法调整后的文件在大多数情况下都能获得比原来更大的压缩率。 该算法具体如下:对一个长度为n的字符串S,首先根据它构造n个字符串,其中第i个字符串由将S的前i-1个字符置于末尾得到。然后把这n个字符串按照首字符从小到大排序,如果两个字符串的首字符相等,则按照它们在S中的位置从小到大排序。排序后的字符串的尾字符可以组成一个新的字符串S’,它的长度也是n,并且包含了S中的每一个字符。最后输出S’以及S的首字符在S’中的位置p。举例: S:example 1、构造n个字符串 example xamplee ampleex mpleexa pleexam leexamp eexampl 2、将字符串排序 ampleex example eexampl leexamp mpleexa pleexam xamplee 3、压缩结果 xelpame S’ 7 p 由于英语单词构造的特殊性,某些字母对出现的频率很高,因此在S’中相同的字母有很大几率排在一起,从而提高S’的压缩率。虽然这种算法利用了英语单词的特性,然而在实践的过程中,人们发现它几乎适用于所有的文件压缩。 请你编一个程序,读入S’p,输出字符串S

输入文件共有三行, 第1行是一个整数n1<=n<=10000),代表S’的长度, 第2行是字符串S’, 第3行是整数p

仅包含一行S

ZIP.IN 7 xelpame 7

ZIP.OUT example

0

 

【培训教程.模拟题】ZIP文件压缩

2017-03-21 21:13:41

1

64

N

0

0

0

1151

【培训教程.模拟题】BATTLE海战

在峰会期间,武装部队得处于高度戒备。警察将监视每一条大街,军队将保卫建筑物,领空将布满了F-2003飞机。此外,巡洋船只和舰队将被派去保护海岸线。不幸的是因为种种原因,国防海军部仅有很少的几位军官能指挥大型海战。因此,他们考虑培养一些新的海军指挥官,他们选择了海战游戏来帮助学习。 在这个著名的游戏中,在一个方形的盘上放置了固定数量和形状的船只,每只船却不能碰到其它的船。在这个题中,我们仅考虑船是方形的,所有的船只都是由图形组成的方形。编写程序求出该棋盘上放置的船只的总数。

输入文件头一行由用空格隔开的两个整数RC组成,1<=R,C<=1000,这两个数分别表示游戏棋盘的行数和列数。 接下来的R行每行包含C个字符,每个字符可以为“#”,也可为“.”“#”表示船只的一部分,“.”表示水。

为每一个段落输出一行解。 如果船的位置放得正确(即棋盘上只存在相互之间不能接触的方形,如果两个“#”号上下相邻或左右相邻却分属两艘不同的船只,则称这两艘船相互接触了)。就输出一段话“There are S ships.”,S表示船只的数量。 否则输出“Bad placement.”

BATTLE.IN 6 8 .....#.# ##.....# ##.....# .......# #......# #..#...#

BATTLE.OUT There are 5 ships.

0

 

【培训教程.模拟题】BATTLE海战(省队)

2017-03-21 21:47:21

1

64

N

0

1

0

1152

【培训教程.模拟题】POLYGON凸多边形

对于一个多边形来说,在该多边形内任取两点,如果这两点连成的线段落在多边形内,则称这样的多边形为凸多边形。 平面上有N个坐标值为自然数的圆点。顶点数最多凸多边形是指由给定的圆点中的一部分组成的凸多边形,它包含最大可能的顶点数。原点,即坐标内中心(00)必须是顶点数最多凸多边形的一个顶点。 编写程序求出这样的凸多边形的最大顶点数。注意一个多边形的连续的边不能是平行的。

输入文件的第一行包含一个自然数N2≤N≤100,表示给定的圆点数。 下面的N行每行包含两个用空格隔开的自然数XY1≤X≤1001≤Y≤100,表示一个圆点的坐标值。 所有的圆点是不相同的。

输出文件的第一行也是唯一的一行应该包含顶点数最多凸多边形的顶点数。 注意结果应不小于3

8 10 8 3 9 2 8 2 3 9 2 9 10 10 3 8 10

8

0

 

【培训教程.模拟题】POLYGON凸多边形

2017-03-25 20:19:40

1

128

N

0

0

0

1153

【培训教程.模拟题】POWER能量

多瑞卡得到了一份有趣而高薪的工作。每天早晨他必须关掉他所在村庄的街灯。所有的街灯都被设置在一条直路的同一侧。 多瑞卡每晚到早晨5点钟都在晚会上,然后他开始关灯。开始时,他站在某一盏路灯的旁边。 每盏灯都有一个给定功率的电灯泡,因为多端卡有着自觉的节能意识,他希望在耗能总数最少的情况下将所有的灯关掉。 多端卡因为太累了,所以只能以1m/s的速度行走。关灯不需要花费额外的时间,因为当他通过时就能将灯关掉。 编写程序,计算在给定路灯设置,灯泡功率以及多端卡的起始位置的情况下关掉所有的灯需耗费的最小能量。

输入文件的第一行包含一个整数N2≤N≤1000,表示该村庄路灯的数量。 第二行包含一个整数V1≤V≤N,表示多瑞卡开始关灯的路灯号码。 接下来的N行中,每行包含两个用空格隔开的整数DW,用来描述每盏灯的参数,其中0≤D≤10000≤W≤1000 D表示该路灯与村庄开始处的距离(用米为单位来表示) W表示灯泡的功率,即在每秒种该灯泡所消耗的能量数。路灯是按顺序给定的。

输出文件的第一行即唯一的一行应包含一个整数,即消耗能量之和的最小值。 注意结果小超过1,000,000,000

POWER.IN 4 3 2 2 5 8 6 1 8 7

POWER.OUT 56

0

 

【培训教程.模拟题】POWER能量

2017-03-22 20:38:34

1

64

N

0

0

0

1154

【培训教程.模拟题】WEDDING婚礼

斯拉夫克正为他的朋友麦克组织一场婚礼。 婚礼最吸引人的特色将是被称为火车的流行舞蹈。所有的客人都一个挨一个地排成长队,队伍中除第一个人外其余所有人都将自己的双手放在前一个人的双肩上,然后快乐地跳着穿过客厅,有时甚至穿过厨房。 斯拉夫克希望他的火车看起来漂亮一点。如果排在一起的两个人身高相差太大,则火车看起来将不漂亮。 麦克的家庭是非常保守的,他们是不允许来自他们家庭中的年轻成员站在年长成员前面的。其余的人能站在他们想站的任何地方。 现给出所有客人的身高以及麦克家庭成员的年龄顺序。编写程序用来分配火车中的客人,以保证每个麦克家庭成员面前没有比他年轻的家庭成员,并且要求在火车中每相邻两个的身高差之和是最小的。

输入文件的第一行是两个用空格隔开的整数NK, 其中1≤N≤100001≤K≤1000,K≤N,分别表示参加婚礼的总人数和麦克家庭成员的人数。 接下来的N行是一个整数V1000≤V≤2200,表示每个客人的身高。 客人用数字1N标明,并且前K个客人是麦克的家庭成员,按年龄的降序排列。 (因此客人1号即麦克家庭成员中的最年长者,客人K号即最年轻的)

在第一行写出火车中相邻两个人身高差之和的最小值。 在接下来的N行中按客人在最佳火车中的排列写出客人的标号,写到结束。 注意解决方案不一定要求是唯一的。

5 3 1900 1300 1500 1200 1600

1000 1 5 4 2 3

0

 

【培训教程.模拟题】WEDDING婚礼

2017-03-25 20:24:40

1

128

N

0

0

0

1155

【培训教程.模拟题】AREA多边形的面积

给出一个简单多边形(没有缺口),它的边要么是垂直的,要么是水平的。要求计算多边形的面积。 多边形被放置在一个X-Y的卡笛尔平面上,它所有的边都平行于两条坐标轴之一。然后按逆时针方向给出各顶点的坐标值。所有的坐标值都是整数(因此多边形的面积也为整数)

输入文件第一行给出多边形的顶点数n(n≤100)。 接下来的几行每行给出多边形一个顶点的坐标值XY(都为整数并且用空格隔开)。 顶点按逆时针方向逐个给出。并且多边形的每一个顶点的坐标值-200≤x,y≤200。 多边形最后是靠从最后一个顶点到第一个顶点画一条边来封闭的。

输出文件仅有一行包含一个整数,表示多边形的面积。

AREA.IN 10 0 0 4 0 4 1 3 1 3 3 2 3 2 2 1 2 1 3 0 3

AREA.OUT 9

0

 

【培训教程.模拟题】AREA多边形的面积

2017-03-22 20:43:14

1

64

N

0

1

0

1156

【培训教程.模拟题】MARICA玛丽卡

麦克找了个新女朋友,玛丽卡对他非常恼火并伺机报复。 因为她和他们不住在同一个城市,因此她开始准备她的长途旅行。 在这个国家中每两个城市之间最多只有一条路相通,并且我们知道从一个城市到另一个城市路上所需花费的时间。 麦克在车中无意中听到有一条路正在维修,并且那儿正堵车,但没听清楚到底是哪一条路。无论哪一条路正在维修,从玛丽卡所在的城市都能到达麦克所在的城市。 玛丽卡将只从不堵车的路上通过,并且她将按最短路线行车。麦克希望知道在最糟糕的情况下玛丽卡到达他所在的城市需要多长时间,这样他就能保证他的女朋友离开该城市足够远。 编写程序,帮助麦克找出玛丽卡按最短路线通过不堵车道路到达他所在城市所需的最长时间(用分钟表示)

第一行有两个用空格隔开的数NM,分别表示城市的数量以及城市间道路的数量。1≤N≤10001≤M≤N*(N-1)/2。 城市用数字1N标识,麦克在城市1中,玛丽卡在城市N中。 接下来的M行中每行包含三个用空格隔开的数ABV。其中1≤AB≤N1≤V≤1000。 这些数字表示在A和城市B中间有一条双行道,并且在V分钟内是就能通过。

输出文件的第一行中写出用分钟表示的最长时间,在这段时间中,无论哪条路在堵车,玛丽卡应该能够到达麦克处, 如果少于这个时间的话,则必定存在一条路,该条路一旦堵车,玛丽卡就不能够赶到麦克处。

5 7 1 2 8 1 4 10 2 3 9 2 4 10 2 5 1 3 4 7 3 5 10

27

0

 

【培训教程.模拟题】MARICA玛丽卡

2017-03-25 20:24:29

1

128

N

0

0

0

1157

【培训教程.模拟题】PASTE粘贴

我们用文本处理器来处理一个特殊的文本文件,该文本文件共有N行文本,每一行文本仅包含一个自然数,第一行为1、第二行为2,以此类推至N行为自然数N。 假设对该文本文件执行一次剪切和粘贴操作含义如下:首先选定连续的若干行文本,剪切操作将选定的文本从文件中剪下,而粘贴操作将剪切下来的文本插入到文件中的其他地方。 编写一个程序求出在进行了连续若干次剪切和粘贴操作后,文本文件中前十行的内容。

输入文件的第一行包含两个用空格隔开的自然数NK N表示文件的总行数(10≤N≤100,000)K表示剪切和粘贴的总次数(1≤k≤1000)。 下面K行每一行包含一次剪切和粘贴操作的执行信息, 每行包含三个用空格隔开自然数ABC,其中1≤A≤B≤N0≤C≤N-(B-A+1) AB表示选定文本的第一行和最后一行, C表示被剪切下来的文本待插入处的前一行, 如果C等于0则被剪切下来的的文本将被插入到文件的开头。

输出文件,将由十行组成,其中包含所有的操作都完成后的文本文件中前十行所包含的数字。

13 3 6 12 1 2 9 0 10 13 8

6 7 8 9 10 11 12 2 3 4

0

 

【培训教程.模拟题】PASTE粘贴

2017-03-25 20:24:18

1

128

N

0

0

0

1158

[培训教程.模拟题]SEARCH路线搜索

年轻的拉尔夫开玩笑地从一个小镇上偷走了一辆车,但他没想到的是那辆车属于警察局,并且车上装有用于发射车子移动路线的装置。 那个装置太旧了,以至于只能发射关于那辆车的移动路线的方向信息。 编写程序,通过使用一张小镇的地图帮助警察局找到那辆车。程序必须能表示出该车最终所有可能的位置。 小镇的地图是矩形的,上面的符号用来标明哪儿可以行车哪儿不行。“.”表示小镇上那块地方是可以行车的,而符号“X”表示此处不能行车。拉尔夫所开小车的初始位置用字符的“*”表示,且汽车能从初始位置通过。 汽车能向四个方向移动:向北(向上),向南(向下),向西(向左),向东(向右)。 拉尔夫所开小车的行动路线是通过一组给定的方向来描述的。在每个给定的方向,拉尔夫驾驶小车通过小镇上一个或更多的可行车地点。

输入文件的第一行包含两个用空格隔开的自然数RC1≤R≤501≤C≤50, 分别表示小镇地图中的行数和列数。 以下的R行中每行都包含一组C个符号(“.”“X”“*”)用来描述地图上相应的部位。 接下来的第R+2行包含一个自然数N1≤N≤1000,表示一组方向的长度。 接下来的N行幅行包含下述单词中的任一个:NORTH()SOUTH()WEST(西)EAST(),表示汽车移动的方向, 任何两个连续的方向都不相同。<br />

输入文件的第一行包含两个用空格隔开的自然数RC1≤R≤501≤C≤50, 分别表示小镇地图中的行数和列数。 以下的R行中每行都包含一组C个符号(“.”“X”“*”)用来描述地图上相应的部位。 接下来的第R+2行包含一个自然数N1≤N≤1000,表示一组方向的长度。 接下来的N行幅行包含下述单词中的任一个:NORTH()SOUTH()WEST(西)EAST(),表示汽车移动的方向, 任何两个连续的方向都不相同。<br /> 输出<br />

4 5 ..... .X... ...*X X.X.. 3 NORTH WEST SOUTH

..... *X*.. *.*.X X.X..

0

 

【培训教程.模拟题】SEARCH路线搜索

2017-03-25 20:24:06

1

128

N

0

0

0

1159

【培训教程.模拟题】FORMAT文件排版

写电子邮件是有趣的,但不幸的是经常写不好看,主要是因为所有的行不一样长,你的上司想要发排版精美的电子邮件,你的任务是为他编写一个电子邮件排版程序。 完成这个任务最简单的办法是在太短的行中的单词之间插入空格,但这并不是最好的方法,考虑如下例子: **************************** This is the example you are actually considering. 假设我们想将第二行变得和第一行一样长,靠简单地插入空格则我们将得到如下结果: **************************** This is the example you are actually considering. 但这太难看了,因为在第二行中有一个非常大的空白,如果将第一行的单词“are”移到下一行我们将得到较好的结果: **************************** This is the example you are actually considering. 当然,这必须对难看程度进行量化。因此我们必须给出单词之间的空格的难看程度,一个包含N个空格符的空白段,其难看程度值为(n-1)2,程序的目的是使难看程度的总和最小化。例如,第一个例子的难看程度是1+7*7=50,而第二个例子的难看程度仅为1+1+1+4+1+4=12。 输出时,每一行的开头和结尾处都必须是一个单词,即每行开头和结尾处不能有空白。唯一例外的是该行仅有一个单词组成的情况,对于这种情况你可将单词放在该行开头处输出,此时如果该单词比该行应有的长度短则我们指定它的最坏程度为500,当然在这种情况下,该行的实际长度即为该单词的长度。

输入文件第一行是一个整数N,表示该段要求达到的宽度,1<=N<=80。 该段文章由一个或多个单词组成,单词由ASCII码值为33126(包含33126)的字符组成,单词与单词之间用空格隔开(可能超过一个)。 单词长度不会超过段落要求达到的宽度。 一段文字所有单词的总长度不会超过10000个字符, 任何一行都不会超过100个字符, 任何一个单词都在同一行内。

对于每个段落,找出使其难看程度最小的排版形式并输出句子:“Minimal badness is B.”, B是指按可能的最好排版形式会发生的难看程度值。 注意排版后文本行数任意,多余的空格也可删除。

FORMAT.IN 28 This is the example you are actually considering.

FORMAT.OUT Minimal badness is 12.

0

 

【培训教程.模拟题】FORMAT文件排版

2017-03-22 20:51:53

1

64

N

0

2

0

1160

【培训教程.模拟题】PUZZLE纵横填字游戏

这个题目要求你编写一个程序用来解决一个纵横填字游戏。这个游戏比我们在报纸上见到的通常的填字游戏要简单。 游戏仅给出单词的起始位置,方面(横向或纵向)以及单词的长度。 只要单词的长度正好,游戏中能填入任何一个来自词典的单词。 在游戏中单词相交处的字母必须相同,当然,任何单词只准使用一次。 思考一下以下这个游戏。例如,假定从上到下有5行,用04来表示,从左到右有5列,用04来表示。 我们用(X,Y)来表示填字游戏中第X列和第Y行的字母。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1160/p1160.gif > 在这个游戏中,我们需填入5个单词: 在(0,0)的右边一个填入4个字母的单词, 在(0,0)的下方填八一个4个字母的单词, 在(2,0)的下方填入一个4个字母的单词, 在(0,2)的右边填入一个3个字母的单词, 最后在(2,3)的右边填入一个3个字母的单词。 字典上所有的单词都能使用但最多只能使用一次。例如,以下是一个可能的解决方案。 (0,0)右边,LATE (0,0)下面,LIED (2,0)下面,TELL (2,3)右边:LOW

输入文件的第一行是作为字典使用的一个文本文件名,你可以假定这个文件存在,是可读的并且包含最多不超过100000个单词,并且按词典顺序存储,每行一个单词。 字典中所有的单词所含的字母可以是大写或小写。在这个问题中字母的大小写是无关紧要的, 你可以假设字典中所有单词的长度不超过20个字符。 输入文件的下一行包含一个整数n(n≤15),表示要填的单词的数量。 接下来的n行中每行给出关于一个单词的提示,在每个提示中分别给出单词的首字母在填字游戏中的列和行的位置,后面根据单词的方向是横向还是纵向,相应跟字符A或字符D,最后一个数表示该单词的长度,以上数据之间均用空格隔开。 你能作以下的进一步的假设。 1.填字游戏的尺寸不超过10×10 2.游戏盘中放得下所有的单词 3.用给定的词典是能够破解出该游戏的。

输出文件应该包含n行, 输出游戏中可填入的所有单词。单词应该每行出现一个,并且按输入文件中提示的顺序输出。 每个单词中所有的字母必须是大写的。所有的单词必须来自给定的词典文件(忽略大小写)。 任何单词只能使用一次。 对于给定输入文件可能有大量的正确解决方案,你只须输出其中的任意一个解决方案。

按上面的填字游戏为例,输入文件应为: PUZZLE.IN WORDS.TXT 5 0 0 A 4 0 0 D 4 2 0 D 4 0 2 A 3 2 3 A 3

一个可能的样例输出 PUZZLE.OUT LATE LIED TELL EEL LOW

0

本题共有五组数据: <p><a href="http://10.10.10.3:8080/JudgeOnline/images/p1160/WORDS1.TXT">word1</a></p> <p><a href="http://10.10.10.3:8080/JudgeOnline/images/p1160/WORDS2.TXT">word2</a></p> <p><a href="http://10.10.10.3:8080/JudgeOnline/images/p1160/WORDS3.TXT">word3</a></p> <p><a href="http://10.10.10.3:8080/JudgeOnline/images/p1160/WORDS4.TXT">word4</a></p> <p><a href="http://10.10.10.3:8080/JudgeOnline/images/p1160/WORDS5.TXT">word5</a></p>

【培训教程.模拟题】PUZZLE纵横填字游戏

2017-03-22 20:52:55

1

64

N

0

0

0

1161

【培训教程.模拟题】RECUR普通递归关系

<img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1161/p1161a.gif >

<img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1161/p1161b.gif >

<img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1161/p1161c.gif >

RECUR1.IN 0 1 1 1 20 RECUR2.IN 0 1 -1 0 1000000000 RECUR3.IN -1 1 4 -3 18

RECUR1.OUT 6765 RECUR2.OUT -1 RECUR3.OUT 387420487

0

 

【培训教程.模拟题】RECUR普通递归关系

2017-03-25 20:17:30

1

64

N

1

3

0

1162

【培训教程.模拟题】SYMMETRY完美的对称

在峰会期间,必须使用许多保镖保卫北约组织的各国代表。代表们除了由他自己的随身保镖保护外,组委会还指派了一些其他的特工和阻击手保护他们。为了使他们的工作卓有成效,使被保卫的人的安全尽可能得到保障,保镖被分配到被保护人的各个方向。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1162.gif > 保镖的最佳站立位置应该是这样的:被保护人应站在所有保镖的对称中心。但是,只要被保护人一移动,保镖就很难根据要人的新位置调整位置。大多数的特工都很难对此作出实时调整。 因此,内政部长高斯决定将该过程逆转一下,保镖先站好自己的位置,然后要人在他们的对称中心找到合适的位置。如果要人随便走动,我们就对他的安全不必负责。 你的工作是使这个过程自动操作。给出一组N个点(保镖的位置),你要找出它们的对称中心S,在这儿被保护人将相对安全。下面以此类推。 首先我们给定一点A以及对称中心S,点A'是点AS为对称中心形成的像点,即点S是线段AA'的对称中心。 点阵组(X)以S为中心的像点是由每个点的像点组成的点阵组。X是用来产生对称中心S的,即点阵XS为中心的像点的集合即为点阵X本身。

输入文件第一行是一个整数N1<=N<=20000, 接下来的N行每行包含用空格隔开的两个整数XiYi-100000<=Xi,Yi<=100000, 表示这组点阵中第I个点的笛卡尔坐标值。 因为任何两个保镖都不会站在同一个位置上,所以在给定的作业中,任何两点都不相同。 但注意保镖可以站在被保护人相同的位置。

输出文件仅有一行。 如果给定的点阵能产生一个对称中心,则输出“V.I.P should stay at (x,y)”, 其中XY代表中心的笛卡尔坐标值,格式为四舍五入保留至小数点后一位。 如果该组点阵无对称中心,输出"This is a dangerous situation.", 注意输出时除了两个单词之间用一个空格隔开外,不要输出多余空格。

SYMMETRY.IN 8 1 10 3 6 6 8 6 2 3 -4 1 0 -2 -2 -2 4

SYMMETRY.OUT V.I.P. should stay at (2.0,3.0).

0

 

【培训教程.模拟题】SYMMETRY完美的对称

2017-03-25 20:17:30

1

64

N

0

1

0

1163

【培训习题.回溯法】1.1knight马拦过河卒

棋盘上A点有一个过河卒,需要走到目标B点。卒行走的规则:可以向下、或者向右。同时在棋盘上C点有一个对方的马,该马所在的点和所有跳跃一步可达的点称为对方马的控制点。因此称之为马拦过河卒。 棋盘用坐标表示,A(0, 0)B(n, m)(n, m为不超过15的整数),同样马的位置坐标是需要给出的。现在要求你计算出卒从A点能够到达B点的路径的条数,假设马的位置是固定不动的,并不是卒走一步马走一步。

一行四个数据,分别表示B点坐标和马的坐标。

一个数据,表示所有的路径条数。

knight.in 6 6 3 3

knight.out 6

0

 

【培训习题.回溯法】1.1knight马拦过河卒

2018-02-02 10:50:18

2

64

N

31

64

0

1164

【培训习题.回溯法】1.2stack出栈序列统计

栈是常用的一种数据结构,有n令元素在栈顶端一侧等待进栈,栈顶端另一侧是出栈序列。 你已经知道栈的操作有两种:pushpop,前者是将一个元素进栈,后者是将栈顶元素弹出。 现在要使用这两种操作,由一个操作序列可以得到一系列的输出序列。 请你编程求出对于给定的n,计算并输出由操作数序列12n,经过一系列操作可能得到的输出序列总数。

一个整数n1<=n<=15

一个整数,即可能输出序列的总数目。

stack.in 3

stack.out 5

0

 

【培训习题.回溯法】1.2stack出栈序列统计

2017-03-25 20:17:30

1

64

N

33

56

0

1165

【培训习题.回溯法】1.3point2424

几十年前全世界就流行一种数字游戏,至今仍有人乐此不疲.在中国我们把这种游戏称为24。您作为游戏者将得到41~9之间的自然数作为操作数,而您的任务是对这4个操作数进行适当的算术运算,要求运算结果等于24。 您可以使用的运算只有:+-*/,您还可以使用()来改变运算顺序。注意:所有的中间结果须是整数,所以一些除法运算是不允许的(例如,(2*2)/4是合法的,2*(2/4)是不合法的)。下面我们给出一个游戏的具体例子: 若给出的4个操作数是:1237,则一种可能的解答是1+2+3*7=24

只有一行,四个19之间的自然数。

如果有解的话,只要输出一个解,输出的是三行数据,分别表示运算的步骤。 其中第一行是输入的两个数和一个运算符和运算后的结果, 第二行是第一行的结果和一个输入的数据、运算符、运算后的结果; 第三行是第二行的结果和输入的一个数、运算符和“=24”。 如果两个操作数有大小的话则先输出大的。 如果没有解则输出“No answer!”

point24.in 1 2 3 7

point24.out 2+1=3 7*3=21 21+3=24

0

 

【培训习题.回溯法】1.3point2424

2017-03-25 20:17:30

1

64

N

14

43

0

1166

【培训习题.回溯法】1.4redund冗余依赖

在设计关系数据库的表格时,术语函数依赖FD)被用来表示不同域之间的关系。函数依赖是描述一个集合中的域的值与另一个集合中的域的值之间的关系。记号X->Y被用来表示当集合X中的域被赋值后,集合Y的域就可以确定相应的值。例如,一个数据表格包含社会治安编号S)、姓名N)、地址A)、电话P)的域,并且每个人都与某个特定的互不相同的S值相对应,根据域S就可以确定域NAP的值。这就记作S->NAP。 写一个程序以找出一组依赖中所有的冗余依赖。一个依赖是冗余的是指它可以通过组里的其他依赖得到。例如,如果组里包括依赖A->BB->CA->C,那么第三个依赖是冗余的,因为域C可以用前两个依赖得到(域A确定了域B的值,同样域B确定了域C的值)。在A->BB->CC->AA->CC->BB->A中,所有的依赖都是冗余的。 现在要求你编写一个程序,从给定的依赖关系中找出冗余的。

A的文件第一行是一个不超过100的整数n,它表示文件中函数依赖的个数。 从第二行起每一行是一个函数依赖且互不重复,每行包含用字符“-”“>”隔开的非空域列表。列表月包含大写的字母,函数依赖的数据行中不包括空格和制表符,不会出现平凡冗余依赖(如A->A)。 虽然文件中没有对函数依赖编号,但其顺序就是编号1n

每一个冗余依赖,以及其他依赖的一个序列以说明该依赖是冗余的,先是一个FD,然后是依赖函数号,接着是"is redundant using FDs最后是说明的序列号。 如果许多函数依赖的序列都能被用来说明一个依赖是冗余的,则输出其中最短的证明序列。如果这些函数依赖中不包含冗余依赖,则输出“No redundant FDs”信息。

redund1.in 3 A->BD BD->C A->C redund2.in 6 P->RST VRT->SQP PS->T Q->TR QS->P SR->V

redund1.out FD 3 is redundant using FDs: 1 2 {C可以通过12得到} redund2.out FD 3 is redundant using FDs: 1 FD 5 is redundant using FDs: 4 6 2

0

 

【培训习题.回溯法】1.4redund冗余依赖

2017-03-25 20:25:25

1

64

N

0

1

0

1167

【培训习题.回溯法】1.5maze走迷宫

有一个m*n格的迷宫(表示有m行、n),其中有可走的也有不可走的,如果用1表示可以走,0表示不可以走, 文件读入这m*n个数据和起始点、结束点(起始点和结束点都是用两个数据来描述的,分别表示这个点的行号和列号)。 现在要你编程找出所有可行的道路,要求所走的路中没有重复的点,走时只能是上下左右四个方向。 如果一条路都不可行,则输出相应信息(-l表示无路)

第一行是两个数mn(1<mn<15), 接下来是mn列由10组成的数据,最后两行是起始点和结束点。

所有可行的路径,描述一个点时用(xy)的形式,除开始点外,其他的都要用>”表示方向。 如果没有一条可行的路则输出-1

maze.in 5 6 1 0 0 1 0 1 1 1 1 1 1 1 0 0 1 1 1 0 1 1 1 1 1 0 1 1 1 0 1 1 1 1 5 6

maze.out (1,2)->(2,1)->(2,2)->(2,3)->(2,4)->(2,5)->(3,5)->(3,4)->(3,3)->(4,3)->(4,4)->(4,5)->(5,5)->(5,6) (1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(2,5)->(3,5)->(3,4)->(4,4)->(4,5)->(5,5)->(5,6) (1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(2,5)->(3,5)->(4,5)->(5,5)->(5,6) (1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(3,4)->(3,3)->(4,3)->(4,4)->(4,5)->(5,5)->(5,6) (1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(3,4)->(3,5)->(4,5)->(5,5)->(5,6) (1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(3,4)->(4,4)->(4,5)->(5,5)->(5,6) (1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,4)->(2,4)->(2,5)->(3,5)->(4,5)->(5,5)->(5,6) (1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,4)->(3,5)->(4,5)->(5,5)->(5,6) (1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,4)->(4,4)->(4,5)->(5,5)->(5,6) (1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(4,3)->(4,4)->(3,4)->(2,4)->(2,5)->(3,5)->(4,5)->(5,5)->(5,6) (1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(4,3)->(4,4)->(3,4)->(3,5)->(4,5)->(5,5)->(5,6) (1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(4,3)->(4,4)->(4,5)->(5,5)->(5,6)

0

 

【培训习题.回溯法】1.5maze走迷宫

2017-03-25 20:25:25

1

64

N

15

65

0

1168

【培训习题.回溯法】1.6track单向双轨道

如图所示l,某火车站有BC两个调度站,左边入口A处有n辆火车等待进站(从左到右以abcd编号),右边是出口D,规定在这一段,火车从A进入经过BC只能从左向右单向开,并且BC调度站不限定所能停放的车辆数。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1168.gif > 从文件输入nn个小写字母的一个排列,该排列表示火车在出口D处形成的从左到右的火车编号序列。 输出为一系列操作过程,每一行形如“h L R”的字母序列,其中h为火车编号,Lh车原先所在位置(位置都以ABCD表示)R为新位置。 或者输出‘NO’表示不能完成这样的调度。

一个数n(1<n<27)及由n个小写字母组成的字符串。

可以调度则输出最短的调度序列,不可以调度时则输出‘NO’

track.in 3 cba

track.out c A B b A C a A D b C D c B D

0

 

【培训习题.回溯法】1.6track单向双轨道

2017-03-25 20:25:25

1

64

N

0

1

0

1169

【培训习题.回溯法】1.7track组合的输出

排列与组合是常用的数学方法,其中组合就是从n个元素中抽出r个元素(不分顺序且r<n),我们可以简单地将n个元素理解为自然数12n,从中任取r个数。 现要求你不用递归的方法输出所有组合。 例如n5r3,所有组合为: l 2 3 l 2 4 1 2 5 l 3 4 l 3 5 1 4 5 2 3 4 2 3 5 2 4 5 3 4 5

一行两个自然数nr(1<n<211<r<n)

所有的组合,每一个组合占一行且其中的元素按由小到大的顺序排列,每个元素占三个字符的位置,所有的组合也按字典顺序。

compages.in 5 3

compages.out 1 2 3 1 2 4 1 2 5 1 3 4 1 3 5 1 4 5 2 3 4 2 3 5 2 4 5 3 4 5

0

 

【培训习题.回溯法】1.7track组合的输出

2017-03-25 20:25:25

1

64

N

15

54

0

1170

【培训习题.回溯法】1.8salesman售货员的难题

某乡有n个村庄(1<n<40),有一个售货员,他要到各个村庄去售货,各村庄之间的路程s(0<s<1000)是已知的,且A村到B村与B村到A村的路大多不同。为了提高效率,他从商店出发到每个村庄一次,然后返回商店所在的村,假设商店所在的村庄为1,他不知道选择什么样的路线才能使所走的路程最短。请你帮他选择一条最短的路。

村庄数n和各村之间的路程(均是整数)

最短的路程。

salesman.in 3 {村庄数} 0 2 l {村庄1到各村的路程} 1 0 2 {村庄2到各村的路程} 2 1 0 {村庄3到各村的路程}

salesman.out 3

0

 

【培训习题.回溯法】1.8salesman售货员的难题

2017-03-25 20:25:25

50

64

N

11

53

0

1171

【培训习题.回溯法】1.9tour驾车旅游

如今许多普通百姓家有了私家车,一些人喜爱自己驾车从一个城市到另一个城市旅游。自己驾车旅游时总会碰到加油和吃饭的问题,在出发之前,驾车人总要想方设法得到从一个城市到另一个城市路线上的加油站的列表,列表中包括了所有加油站的位置及其每升的油价(3.25/L)。驾车者一般都有以下的习惯: (1)除非汽车无法用油箱里的汽油达到下一个加油站或目的地,在油箱里还有不少于最大容量一半的汽油时,驾驶员从不在加油站停下来; (2)在第一个停下的加油站总是将油箱加满; (3)在加油站加油的同时,买快餐等吃的东西花去20元。 (4)从起始城市出发时油箱总是满的。 (5)加油站付钱总是精确到0.1(四舍五入)。 (6)驾车者都知道自己的汽车每升汽油能够行驶的里程数。 现在要你帮忙做的就是编写一个程序,计算出驾车从一个城市到另一个城市的旅游在加油和吃饭方面最少的费用。

第一行是一个实数,是从出发地到目的地的距离(单位:km)。 第二行是三个实数和一个整数,其中第一个实数是汽车油箱的最大容量(单位:I); 第二个实数是汽车每升油能行驶的公里数; 第三个实数是汽车在出发地加满油箱时的费用(单位元);一个整数是150间的数,表示从出发地到目的地线路上加油站的数目。 接下来n行都是两个实数, 第一个数表示从出发地到某一个加油站的距离(单位:km); 第二个实数表示该加油站汽油的价格(单位:元)。 数据项中的每个数据都是正确的,不需判错。一条线路上的加油站根据其到出发地的距离递增排列并且都不会大于从出发地到目的地的距离。

就一个数据,是精确到0.1元的最小的加油和吃饭费用

tour.in 600 40 8.5 128 3 200 3.52 350 3.45 500 365

tour.out 379.6

0

 

【培训习题.回溯法】1.9tour驾车旅游

2017-03-25 20:28:07

1

64

N

0

1

0

1172

【培训习题.回溯法】1.10power关路灯

某一村庄在一条路线上安装了n盏路灯,每盏灯的功率有大有小(即同一段时间内消耗的电量有多有少)。老张就住在这条路中间某一路灯旁,他有一项工作就是每天早上天亮时一盏一盏地关掉这些路灯。 为了给村里节省电费,老张记录下了每盏路灯的位置和功率,他每次关灯时也都是尽快地去关,但是老张不知道怎样去关灯才能够最节省电。他每天都是在天亮时首先关掉自己所处位置的路灯,然后可以向左也可以向右去关灯。开始他以为先算一下左边路灯的总功率再算一下右边路灯的总功率,然后选择先关掉功率大的一边,再回过头来关掉另一边的路灯,而事实并非如此,因为在关的过程中适当地调头有可能会更省一些。 现在已知老张走的速度为1m/s,每个路灯的位置(是一个整数,即距路线起点的距离,单位:m)、功率(W),老张关灯所用的时间很短而可以忽略不计。 请你为老张编一程序来安排关灯的顺序,使从老张开始关灯时刻算起所有灯消耗电最少(灯关掉后便不再消耗电了)。

文件第一行是两个数字n(0<n<50,表示路灯的总数)c(1<c<=n老张所处位置的路灯号); 接下来n行,每行两个数据,表示第1盏到第n盏路灯的位置和功率。

一个数据,即最少的功耗(单位:J1J1W•s)

power.in 5 3 2 10 3 20 5 20 6 30 8 10

power.out 270 {此时关灯顺序为3 4 2 1 5,不必输出这个关灯顺序}

0

 

【培训习题.回溯法】1.10power关路灯

2017-03-25 20:28:07

10

64

N

1

5

0

1173

【培训习题.递规与递推】2.1travel遍历问题

我们都很熟悉二叉树的前序、中序、后序遍历,在数据结构中常提出这样的问题:已知一棵二叉树的前序和中序遍历,求它的后序遍历,相应的,已知一棵二叉树的后序遍历和中序遍历序列你也能求出它的前序遍历。 然而给定一棵二叉树的前序和后序遍历,你却不能确定其中序遍历序列,考虑如下图中的几棵二叉树: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1173.gif > 所有这些二叉树都有着相同的前序遍历和后序遍历,但中序遍历却不相同。

A数据共两行, 第一行表示该二叉树的前序遍历结果s1, 第二行表示该二叉树的后序遍历结果s2

输出可能的中序遍历序列的总数,结果不超过长整型数。

trave1.in abc cba

trave1.out 4

0

 

【培训习题.递规与递推】2.1travel遍历问题

2017-03-25 20:28:07

1

64

N

13

47

0

1174

【培训习题.递规与递推】2.2build产生数

给出一个整数n(n<10^30)m个变换规则(m≤20)。 约定:一个数字可以变换成另一个数字,规则的右部不能为零,即零不能由另一个数字变换而成。而这里所说的一个数字就是指一个一位数。 现在给出一个整数nm个规则,要你求出对n的每一位数字经过任意次的变换(0次或多次),能产生出多少个不同的整数。

m+2行, 第一行是一个不超过30位的整数n, 第2行是一个正整数m, 接下来的m行是m个变换规则,每一规则是两个数字xy,中间用一个空格间隔,表示x可以变换成y

仅一行,表示可以产生的不同整数的个数。

build.in 123 2 1 2 2 3

build.out 6

0

 

【培训习题.递规与递推】2.2build产生数

2018-03-19 13:28:02

1

64

N

6

46

0

1175

【培训习题.递规与递推】2.3stack出栈序列

栈是常用的一种数据结构,有n个元素在栈顶端一侧等待进栈,栈顶端另一侧是出栈序列。 你已经知道栈的操作有两种:pushpop,前者是将一个元素进栈,后者是将栈顶元素弹出。 现在要使用这两种操作,由一个操作序列可以得到一系列的输出序列。 请你编程求出对于给定的n,计算并输出由操作数序列12n,经过一系列操作可能得到的输出序列总数。

就一个数n(1≤n≤1000)

一个数,即可能输出序列的总数目。

stack.in 3

stack.out 5

0

 

【培训习题.递规与递推】2.3stack出栈序列统计

2018-04-12 17:08:52

10

64

N

5

73

0

1176

【培训习题.递规与递推】2.4count计数器

一本书的页数为N,页码从1开始编起,请你求出全部页码中,用了多少个0129。 其中个页码不含多余的0,如N1234时第5页不是0005,只是5

一个正整数N(N≤10<sup>9</sup>),表示总的页码。

共十行:第k行为数字k-1的个数。

count.in 11

count.out 1 4 1 1 1 1 1 1 1 1

0

 

【培训习题.递规与递推】2.4count计数器

2017-03-25 20:28:07

1

64

N

10

27

0

1177

【培训习题.递规与递推】2.5empire诸侯安置

很久以前,有一个强大的帝国,它的国土成正方形状,如图2—2所示。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1177/p1177a.gif > 这个国家有若干诸侯。由于这些诸侯都曾立下赫赫战功,国王准备给他们每人一块封地(正方形中的一格)。但是,这些诸侯又非常好战,当两个诸侯位于同一行或同一列时,他们就会开战。如下图2—3n3时的国土,阴影部分表示诸侯所处的位置。前两幅图中的诸侯可以互相攻击,第三幅则不可以。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1177/p1177b.gif > 国王自然不愿意看到他的诸侯们互相开战,致使国家动荡不安。 因此,他希望通过合理的安排诸侯所处的位置,使他们两两之间都不能攻击。 现在,给出正方形的边长n,以及需要封地的诸侯数量k,要求你求出所有可能的安置方案数。(n≤l00k≤2n2-2n+1) 由于方案数可能很多,你只需要输出方案数除以504的余数即可。

仅一行,两个整数nk,中间用一空格隔开。

一个整数,表示方案数除以504的余数。

empire.in 2 2

empire.out 4

0

【样例说明】 四种安置方案如图2-4所示。注意:镜面和旋转的情况属于不同的方案。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1177/p1177c.gif >

【培训习题.递规与递推】2.5empire诸侯安置

2017-03-25 20:28:07

1

64

N

5

15

0

1178

【培训习题.递规与递推】2.6bracket括号序列

定义如下规则序列(字符串) 1.空序列是规则序列; 2.如果S是规则序列,那么(S)[S]也是规则序列; 3.如果AB都是规则序列,那么AB也是规则序列。 例如,下面的字符串都是规则序列: ()[](())([])()[]()[()] 而以下几个则不是: ([])(())([() 现在,给你一些由‘(’‘)’‘[’‘]’构成的序列,你要做的,是找出一个最短规则序列,使得给你的那个序列是你给出的规则序列的子列。(对于序列a1a2, 和序列blb2, ,如果存在一组下标1≤i1<i2<…< ≤m,使得aj= 对一切1≤j≤n成立,那么a1a2…, 就叫做b1b2, 的子列。

输入文件仅一行,全部由‘(’‘)’‘]’‘]’组成,没有其他字符,长度不超过100

输出文件也仅有一行,全部由‘(’‘)’‘]’‘]’组成,没有其他字符,把你找到的规则序列输出即可。因为规则序列可能不止一个,因此要求输出的规则序列中嵌套的层数尽可能地少。

bracket.in ([()

bracket.out ()[]() {最多的嵌套层数为1,如层数为2时的一种为()[()]}

0

 

【培训习题.递规与递推】2.6bracket括号序列

2017-03-25 20:28:07

1

64

N

2

21

0

1179

【培训习题.递规与递推】2.7hanoi新汉诺塔

设有n个大小不等的中空圆盘,按从小到大的顺序从1n编号。将这n个圆盘任意的迭套在三根立柱上,立柱的编号分别为ABC,这个状态称为初始状态。 现在要求找到一种步数最少的移动方案,使得从初始状态转变为目标状态。 移动时有如下要求: 一次只能移一个盘; 不允许把大盘移到小盘上面。

文件第一行是状态中圆盘总数; 第二到第四行分别是初始状态中ABC柱上圆盘的个数和从上到下每个圆盘的编号; 第五到第七行分别是目标状态中ABC柱上圆盘的个数和从上到下每个圆盘的编号。

每行一步移动方案,格式为:move I from P to Q 最后一行输出最少的步数。

Hanoi.in 5 3 3 2 1 2 5 4 0 1 2 3 5 4 3 1 1

Hanoi.out move 1 from A to B move 2 from A to C move 1 from B to C move 3 from A to B move 1 from C to B move 2 from C to A move 1 from B to C 7

0

 

【培训习题.递规与递推】2.7hanoi新汉诺塔

2017-03-25 20:28:07

1

64

N

7

8

0

1180

【培训习题.递规与递推】2.8sort排序集合

对于集合N={1,2,…,n}的子集,定义一个称之为小于的关系: 设S1={X1,X2,…,Xi},(X1<X2<…<Xi),S2={Y1, Y2, …,Yj},(Y1<Y2<…<Yj),如果存在一个k,(0≤k≤min(i,j)),使得X1=Y1Xk=Yk,且k=iX(k+1)<Y(k+1),则称S1“小于”S2。 你的任务是,对于任意的n(n≤31)k(k<2n),求出第k小的子集。

输入文件仅一行,包含两个用空格隔开的自然数,nk

输出文件仅一行,使该子集的元素,由小到大排列。空集输出0

sort.in 3 4

sort.out 1 2 3

0

 

【培训习题.递规与递推】2.8sort排序集合

2017-03-25 20:28:07

1

64

N

11

46

0

1181

【培训习题.递规与递推】2.9frog青蛙过河

有一条河,左边一个石墩(A)上有编号为1234nn只青蛙,河中有k个荷叶(C),还有h个石墩(D),右边有一个石墩(B),如下图2—5所示。n只青蛙要过河(从左岸石墩A到右岸石墩B),规则为: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1181.gif > (1)石墩上可以承受任意多只青蛙,荷叶只能承受一只青蛙(不论大小) (2)青蛙可以:A→B(表示可以从A跳到B,下同)A→CA→DC→BD→BD→CC→D (3)当一个石墩上有多只青蛙时,则上面的青蛙只能跳到比它大1号的青蛙上面。 你的任务是对于给出的hk,计算并输出最多能有多少只青蛙可以根据以上规则顺利过河?

 

 

frog.in 2 3 {河中间有2个石礅,3个荷叶}

frog.out 16 {最多有16只青蛙可以按照规则过河}

0

 

【培训习题.递规与递推】2.9frog青蛙过河

2017-03-25 20:29:46

1

64

N

17

21

0

1182

【培训习题.递规与递推】2.10phone电话号码

电话机上每一个数字下面都写了若干个英文字母。分布如下: 1abc 2def 3ghi 4ikl 5mn 6opq 7rst 8uvw 9xyz 现在给定一个单词表和一串数字密码,请你用单词表中的单词翻译这个密码。

第一行为一个正整数N表示单词表中单词的个数(N≤100); 第二行为一个长度不超过100的数字串,表示密码; 接下来的N行,每行一个长度不超过20的单词,表示单词表。

仅一行,表示翻译后的原文, 如果密码无法翻译,则输出“No Solutions!”, 如果密码有多种翻译方式,则输出任意一种即可。

phone.in 8 73373711664 thi shs this is b a boo k

phone.out thi shs b boo k

0

 

【培训习题.递规与递推】2.10phone电话号码

2017-03-25 20:29:46

1

64

N

9

16

0

1183

【培训习题.递规与递推】2.11encode编码

编码工作常被运用于密文或压缩传输。这里我们用一种最简单的编码方式进行编码:把一些有规律的单词编成数宇。 字母表中共有26个字母{abz},这些特殊的单词长度不超过6且字母按升序排列。把所有这样的单词放在一起,按字典顺序排列,一个单词的编码就对应着它在字典中的位置。 例如: a→1 b→2 z→26 ab→27 ac→28 你的任务就是对于所给的单词,求出它的编码。

仅一行,被编码的单词。

仅一行,对应的编码。如果单词不在字母表中,输出0

encode.in ab

encode.out 27

0

 

【培训习题.递规与递推】2.11encode编码

2017-03-25 20:29:46

1

64

N

9

35

0

1184

【培训习题.贪心法】3.1water排队接水

n个人在一个水龙头前排队接水,假如每个人接水的时间为Ti, 请编程找出这n个人排队的一种顺序,使得n个人的平均等待时间最小。

输入文件共两行, 第一行为n; 第二行分别表示第1个人到第n个人每人的接水时间T1T2Tn,每个数据之间有1个空格。

输出文件有两行, 第一行为一种排队顺序,即1n的一种排列; 第二行为这种排列方案下的平均等待时间(输出结果精确到小数点后两位)

water.in 10 56 12 1 99 1000 234 33 55 99 812

water.out 3 2 7 8 1 4 9 6 10 5 291.90

0

 

【培训习题.贪心法】3.1water排队接水

2017-03-25 20:29:46

1

64

N

14

36

0

1185

【培训习题.贪心法】3.2riddle智力大冲浪

小伟报名参加中央电视台的智力大冲浪节目。本次挑战赛吸引了众多参赛者,主持人为了表彰大家的勇气,先奖励每个参赛者m元。先不要太高兴!因为这些钱还不一定都是你的?!接下来主持人宣布了比赛规则: 首先,比赛时间分为n个时段(n≤500),它又给出了很多小游戏,每个小游戏都必须在规定期限ti前完成(1≤ti≤n)。 如果一个游戏没能在规定期限前完成,则要从奖励费m元中扣去一部分钱wiwi为自然数,不同的游戏扣去的钱是不一样的。当然,每个游戏本身都很简单,保证每个参赛者都能在一个时段内完成,而且都必须从整时段开始。主持人只是想考考每个参赛者如何安排组织自己做游戏的顺序。 作为参赛者,小伟很想赢得冠军,当然更想赢取最多的钱!注意:比赛绝对不会让参赛者赔钱!

输入文件riddle.in,共4行。 第1行为m,表示一开始奖励给每位参赛者的钱; 第2行为n,表示有n个小游戏; 第3行有n个数,分别表示游戏1n的规定完成期限; 第4行有n个数,分别表示游戏1n不能在规定期限前完成的扣款数。

输出文件riddle.out,仅1行。表示小伟能赢取最多的钱。

riddle.in 10000 7 4 2 4 3 1 4 6 70 60 50 40 30 20 10

riddle.out 9950

0

 

【培训习题.贪心法】3.2riddle智力大冲浪

2017-03-25 20:29:46

15

64

N

14

30

0

1186

【培训习题.贪心法】3.3match取火柴游戏

输入kk个整数n1n2nk,表示有k堆火柴棒,第i堆火柴棒的根数为ni;接着便是你和计算机取火柴棒的对弈游戏。 取的规则如下:每次可以从一堆中取走若干根火柴,也可以一堆全部取走,但不允许跨堆取,也不允许不取。 谁取走最后一根火柴为胜利者。 例如:k2n1n22A代表你,P代表计算机,若决定A先取: A(2,2)→(1,2) {从一堆中取一根} P(1,2)→(1,1) {从另一堆中取一根} A(1,1)→(1,0) P(1,0)→ (0,0) {P胜利} 如果决定A后取: P(2,2)→(2,0) A(2,0)→ 0,0) {A胜利} 又如k3n1=1n22n33A决定后取: P(1,2,3)→(0,2,3) A(0,2,3)→(0,2,2) A已将游戏归结为(2,2)的情况,不管P如何取A都必胜。 编一个程序,在给出初始状态之后,判断是先取必胜还是先取必败,如果是先取必胜,请输 出第一次该如何取。如果是先取必败,则输出“lose”

 

 

match1.in 3 3 6 9 match2.in 4 15 22 19 10

match1.out 4 3 {表示第一次从第3堆取4个出来,必胜} 3 6 5 {第一次取后的状态} match2.out lose {先取必败}

0

 

【培训习题.贪心法】3.3match取火柴游戏

2017-03-25 20:29:46

1

64

N

14

21

0

1187

【培训习题.贪心法】3.4prod加工生产调度

某工厂收到了n个产品的订单,这n个产品分别在AB两个车间加工,并且必须先在A车间加工后才可以到B车间加工。 某个产品iAB两车间加工的时间分别为AiBi。怎样安排这n个产品的加工顺序,才能使总的加工时间最短。这里所说的加工时间是指:从开始加工第一个产品到最后所有的产品都已在AB两车间加工完毕的时间。

第一行仅个数据n(0

第一行一个数据,表示最少的加工时间; 第二行是一种最小加工时间的加工顺序。

prod.in 5 3 5 8 7 10 6 2 1 4 9

prod.out 34 1 5 4 2 3

0

 

【培训习题.贪心法】3.4prod加工生产调度

2018-03-31 15:08:27

20

64

N

5

16

0

1188

【培训习题.贪心法】3.5maxmul最大乘积

一个正整数一般可以分为几个互不相同的自然数的和,如3=1+24=1+351+4=2+36=1+52+4。 现在你的任务是将指定的正整数n分解成若干个互不相同的自然数的和,且使这些自然数的乘积最大。

只一个正整数n(3≤n≤10000)

第一行是分解方案,相邻的数之间用一个空格分开,并且按由小到大的顺序。 第二行是最大的乘积

maxmul.in 10

maxmul.out 2 3 5 30

0

 

【培训习题.贪心法】3.5maxmul最大乘积

2017-03-25 20:29:46

1

64

N

6

15

0

1189

【培训习题.贪心法】3.6trees种树

一条街的一边有几座房子。因为环保原因居民想要在路边种些树。路边的地区被分割成块,并被编号成1..N。每个部分为一个单位尺寸大小并最多可种一棵树。每个居民想在门前种些树并指定了三个号码BET。这三个数表示该居民想在BE之间最少种T棵树。当然,B≤E,居民必须记住在指定区不能种多于区域地块数的树,所以T≤E-B+l。居民们想种树的各自区域可以交叉。你的任务是求出能满足所有要求的最少的树的数量。 写一个程序完成以下工作: * trees.in读入数据 * 计算最少要种树的数量和位置 * 把结果写到trees.out

第一行包含数据N,区域的个数 ( 0< N <= 30000 ) 第二行包含H,房子的数目 ( 0< H <= 5000 ) 下面的H行描述居民们的需要:B E T( 0 < B ≤ E ≤30000T ≤ E-B+1) 下面的H行描述居民们的需要:B E T,(0 < B <= E <= 30000T <= E-B+1,输入数据B E T中,只保证B <= E )

输出文件只有一行,写有树的最少数目。 (样例中,列出所有树的位置,相邻两数之间用一个空格隔开。仅提供树的最少数目某种情形参考,并不要求输出)

trees.in 9 4 1 4 2 4 6 2 8 9 2 3 5 2

trees.out 5 1 4 5 8 9{此行不要求输出}

0

 

【培训习题.贪心法】3.6trees种树

2018-04-06 17:19:43

10

64

N

2

13

0

1190

【培训习题.贪心法】3.7napkin餐巾

一个餐厅在相继的N天里,第i天需要Ri块餐巾(i=l2N)。餐厅可以从三种途径获得餐巾。 (1)购买新的餐巾,每块需p分; (2)把用过的餐巾送到快洗部,洗一块需m天,费用需f(f<p)。如m=l时,第一天送到快洗部的餐巾第二天就可以使用了,送慢洗的情况也如此。 (3)把餐巾送到慢洗部,洗一块需n(n>m),费用需s(s<f)。 在每天结束时,餐厅必须决定多少块用过的餐巾送到快洗部,多少块送慢洗部。在每天开始时,餐厅必须决定是否购买新餐巾及多少,使洗好的和新购的餐巾之和满足当天的需求量Ri,并使N天总的费用最小。

输入文件共3行, 第1行为总天数; 第2行为每天所需的餐巾块数; 第3行为每块餐巾的新购费用p,快洗所需天数m,快洗所需费用f,慢洗所需天数n,慢洗所需费用s

输出文件共n+1行。 第1行为最小的费用。 下面的n行为从第1天开始每天需要的总餐巾数、需购买的新餐巾数、结束时往快、慢洗部送洗的餐巾数以及用到的来自快洗的餐巾数和来自慢洗的餐巾数。

napkin.in 3 3 2 4 10 1 6 2 3

napkin.out 64 3 3 1 2 0 0 2 1 2 0 1 0 4 0 0 0 2 2

0

 

【培训习题.贪心法】3.7napkin餐巾

2017-03-25 20:29:46

1

64

N

0

2

0

1191

【培训习题.贪心法】3.8marathon马拉松接力赛

某城市冬季举办环城25km马拉松接力赛,每个代表队有5人参加比赛,比赛要求每个的每名参赛选手只能跑一次,一次至少跑1km、最多只能跑10km,而且每个选手所跑的公里数必须为整数,即接力的地方在整公里处。 刘老师作为学校代表队的教练,精心选择了5名长跑能手,进行了训练和测试,得到了这5名选手尽力连续跑1km2km10km的所用时间。现在他要进行一个合理的安排,让每个选手跑合适的公里数,使学校代表队跑完25km所用的时间最短。根据队员的情况,这个最短的时间是惟一的,但安排方案可能并不惟一。 根据测试情况及一般运动员的情况得知,连续跑1km要比连续跑2km速度快,连续跑2km又要比连续跑3km速度快……也就是说连续跑的路程越长,速度越慢,当然也有特殊的,就是速度不会变慢,但是绝不可能变快。

5行数据,分别是15号队员的测试数据, 每行的10个整数,表示某一个运动员尽力连续跑1km2km10km所用的时间。

两行, 第一行是最短的时间, 第二行是五个数据,分别是15号队员各自连续跑的公里数。

marath.in 333 700 1200 1710 2240 2613 3245 3956 4778 5899 300 610 960 1370 1800 2712 3834 4834 5998 7682 298 612 990 1560 2109 2896 3790 4747 5996 7654 289 577 890 1381 1976 2734 3876 5678 6890 9876 312 633 995 1467 1845 2634 3636 4812 5999 8123

marath.out 9748 6 5 5 4 5

0

 

【培训习题.贪心法】3.8marathon马拉松接力赛

2017-03-25 20:31:51

1

64

N

1

3

0

1192

【培训习题.贪心法】3.9storage线性存储问题

磁带等存储介质存储信息时基本上都是一种线性存储的方式,线性存储方式虽然简单,但查询检索时往往要经过一些其它信息,不象磁盘等存储介质在目录区找到后可直接定位到某一区城,因此线性存储总有它的局限性。但是由于磁带等线性存储有简单、保存时间相对较长等优点,现在仍然在使用。 如果有n段信息资料要线性存储在某种存储介质上,它们的长度分别是L1L2Ln,存储介质能够保存下所有这些信息,假设它们的使用(查询检索)的频率分别是F1F2Fn,要如何存储这些信息资料才能使平均检索时间最短。 你的任务就是编程安排一种平均检索时间最短的方案。

第一行是一个正整数n(n<10000), 接下来是n行数据, 每行两个整数分别是第1段信息的长度(110000之间)和使用的频率(万分比,在09000之间),总的频率之和为10000。 所输入数据均不要判错。

依次存储信息段的编号。每个数据之间用一个空格隔开。 (在输出数据中,可能存在着多个相同的最佳方案,在排序时请务必保证数据的稳定性,否则结果可能不一样!)

storage.in 5 10 4000 20 1000 30 1000 35 1500 12 2500

storage.out 4 1 3 5 2

0

 

【培训习题.贪心法】3.9storage线性存储问题

2017-03-25 20:31:51

1

64

N

0

3

0

1193

【培训习题.贪心法】3.10fan.扇区填数

有一个圆,当输入一个整数n(1≤n≤6)后,它被分成n个扇区,请你为每一扇区选择一个自然数(大于0的整数)。 向各个扇区放入数之后,你可以从单个扇区中选出个数,也可以从相邻的两个或多个扇区中各选一个数,相加后形成一个新的数,请使用这些整数形成一个连续的整数序列,:123i,你的任务是使i尽可能地大。

只一个整数n(1<n<6)

第一行是最大的i,接下来的几行是所有能达到最大i的填法。 由于圆里不分顺序,所以同一种填法可以有多种输出。 为了减少这种情况,这里规定从1,开始输出(因为连续数里要有1,所以所填的数中肯定有1)

fan.in 1

fan.out 1 1

0

 

【培训习题.贪心法】3.10fan.扇区填数

2017-03-25 20:31:51

5

64

N

0

3

0

1194

【培训习题.分治】4.1mod取余运算

输入bpk的值,求b^p mod k的值。其中bpk*k为长整型数。

 

 

mod.in 2 10 9

mod.out 2^10 mod 9=7

0

 

【培训习题.分治】4.1mod取余运算

2017-04-16 16:48:38

1

64

N

41

104

0

1195

【培训习题.分治】4.2blank地毯填补问题

<p> 相传在一个古老的阿拉伯国家里,有一座宫殿。宫殿里有个四四方方的格子迷宫,国王选择驸马的方法非常特殊,也非常简单:公主就站在其中一个方格子上,只要谁能用地毯将除公主站立的地方外的所有地方盖上,美丽漂亮聪慧的公主就是他的人了。公主这一个方格不能用地毯盖住,毯子的形状有所规定,只能有四种选择(如图4-l)<img src="/JudgeOnline/upload/image/20180429/20180429084124_26308.png" alt="" />   </p> <p> 并且每一方格只能用一层地毯,迷宫的大小为(2<sup>k</sup>)<sup>2</sup>的方形。当然,也不能让公主无限制的在那儿等,对吧?由于你使用的是计算机,所以实现时间为1s </p>

输入文件共2行。 第一行:k,即给定被填补迷宫的大小为2k(0

将迷宫填补完整的方案:每一补()x y c (xy为毯子拐角的行坐标和列坐标,c为使用毯子的形状,具体见上面的图1,毯子形状分别用1234表示,xyc之间用一个空格隔开)

3 3 3

5 5 1 2 2 4 1 1 4 1 4 3 4 1 2 4 4 1 2 7 3 1 5 4 1 8 3 3 6 3 4 8 1 7 2 2 5 1 4 6 3 2 8 1 2 8 4 1 7 7 1 6 6 1 5 8 3 8 5 2 8 8 1

0

 

【培训习题.分治】4.2blank地毯填补问题

2018-04-29 08:41:55

1

64

N

15

27

0

1196

【培训习题.分治】4.3nearest最接近点对

给定平面上n个点,找出其中的一对点的距离,使得在这n个点的所有点对中,该距离为所有点对中最小的。

第一行:n2≤n≤60000 接下来n行:每行两个实数:x y,表示一个点的行坐标和列坐标,中间用一个空格隔开。

仅一行,一个实数,表示最短距离,精确到小数点后面4位。

nearest.in 3 1 1 1 2 2 2

nearest.out 1.0000

0

 

【培训习题.分治】4.3nearest平面上的最接近点对

2017-03-25 20:31:51

1

64

N

8

49

0

1197

【培训习题.分治】4.4equation求方程的根

<p> 输入mnpab,求方程f(x)m<sup>x</sup>+n<sup>x</sup>-p<sup>x</sup>0[a,b]内的根。mnpab均为整数,且a </p> <p> 保证测试数据中如果方程有解,则只有一个解 </p>

 

 

equation.in 2 3 4 1 2

equation.out 1.5071265916 输出保证小数点后10

0

 

【培训习题.分治】4.4equation求方程的根

2018-04-25 14:13:41

1

64

N

1

4

0

1198

【培训习题.分治】4.5car小车问题

甲、乙两人同时从A地出发要尽快同时赶到B地。出发时A地有一辆小车,可是这辆小车除了驾驶员外只能带一人。已知甲、乙两人的步行速度一样,且小于车的速度。问:怎样利用小车才能使两人尽快同时到达。

仅一行,三个数据分别表示AB两地的距离s,人的步行速度a,车的速度b

两人同时到达B地需要的最短时间。

car.in 120 5 25

car.out(格式:输出时要求小数点保留两位输出) 9.60

0

 

【培训习题.分治】4.5car小车问题

2017-03-25 20:31:51

1

64

N

10

13

0

1199

【培训习题.分治】4.6chessman黑白棋子的移动

2n个棋子(n≥4)排成一行,开始为位置白子全部在左边,黑子全部在右边,如下图为n=5的情况: ○○○○○●●●●● 移动棋子的规则是:每次必须同时移动相邻的两个棋子,颜色不限,可以左移也可以右移到空位上去,但不能调换两个棋子的左右位置。每次移动必须跳过若干个棋子(不能平移),要求最后能移成黑白相间的一行棋子。如n=5时,成为: ○●○●○●○●○● 任务:编程打印出移动过程。

 

 

chessman.in 7

chessman.out step 0:ooooooo*******-- step 1:oooooo--******o* step 2:oooooo--******o* step 3:ooooo--*****o*o* step 4:ooooo*****--o*o* step 5:oooo--****o*o*o* step 6:oooo****--o*o*o* step 7:ooo--***o*o*o*o* step 8:ooo*o**--*o*o*o* step 9:o--*o**oo*o*o*o* step10:o*o*o*--o*o*o*o* step11:--o*o*o*o*o*o*o*

0

 

【培训习题.分治】4.6chessman黑白棋子的移动

2018-04-28 13:17:24

1

64

N

16

68

0

1200

【培训习题.分治】4.7mason麦森数

形如2<sup>p</sup>-1的素数称为麦森数,这时P一定也是个素数。但反过来不一定,即如果P是个素数,2<sup>p</sup>-1不一定也是素数。到1998年底,人们已找到了37个麦森数。最大的一个是P=3021377,它有909526位。麦森数有许多重要应用,它与完全数密切相关。 任务:从文件中输入P(1000<P<3100000),计算2<sup>p</sup>-1的位数和最后500位数字(用十进制高精度数表示)

文件中只包含一个整数P(1000<P<3100000)

第一行:十进制高精度数2<sup>p</sup>-1的位数; 第2--11行:十进制高精度数2<sup>p</sup>-1的最后500位数字(每行输出50位,共输出10行,不足500位时高位补0); 不必验证2<sup>p</sup>-1P是否为素数。

mason.in 1279

mason.out 386 00000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000 00000000000000104079321946643990819252403273640855 38615262247266704805319112350403608059673360298012 23944173232418484242161395428100779138356624832346 49081399066056773207629241295093892203457731833496 61583550472959420547689811211693677147548478866962 50138443826029173234888531116082853841658502825560 46662248318909188018470682222031405210266984354887 32958028878050869736186900714720710555703168729087

0

 

【培训习题.分治】4.7mason麦森数(NOIP2003

2017-03-25 20:31:51

1

64

N

16

23

0

1201

【培训习题.分治】4.8trip旅行家的预算

一个旅行家想驾驶汽车以最少的费用从一个城市到另一个城市(假设出发时油箱是空的)。给定两个城市之间的距离D1、汽车油箱的容量C(以升为单位)、每升汽油能行驶的距离D2、出发点每升汽油价格P和沿途油站数N(N可以为零),油站i离出发点的距离Di、每升汽油价格Pi(i12N)。 计算结果四舍五入至小数点后两位。如果无法到达目的地,则输出“No Solution”

 

 

trip.in 275.6 11.9 27.4 2.8 2 (分别表示D1CD2PN) 102.0 2.9 (以下共N行,分别表示油站i离出发点的距离Di和每升汽油价格Pi) 220.0 2.2

trip.out 26.95(该数据表示最小费用)

0

 

【培训习题.分治】4.8trip旅行家的预算(NOIP1999)

2017-03-25 20:41:55

1

64

N

5

19

0

1202

(原始测试数据什么鬼)【培训习题.分治】4.9trgovac飞行计划

16岁那年,Mirko从大学毕业当起了推销员。他必须访问N个城市一次且仅一次,为他的产品做广告。像所有的推销员一样,他将乘坐飞机来往于城市之间。 每两个城市之间有且仅有一条航线,而且总是花费1小时的时间。飞机一刻不停地沿着航线飞行。飞机的起飞时间总是在整点,例如,飞机中午从城市A起飞,飞向城市B,那么它将在下午1点在城市B降落,然后立即返回城市A,再次到达城市A的时间应该是下午2点。 Mirko想作一个计划,使得他可以在沿途的每个城市(不包括起点和终点)花上一小时做广告,然后立即前往下一个城市。换句话说,他想把N个城市排成一个序列g1,…gn,对于每个i(1

 

 

 

 

0

 

【培训习题.分治】4.9trgovac飞行计划

2017-03-25 20:46:56

1

64

Y

1

1

0

1206

【培训习题.图】5.4AGE间谍网络

<span style="color:#333333;font-family:"font-size:14px;background-color:#EEEEEE;">由于外国间谍的大量渗入,国家安全正处于高度的危机之中。如果A间谍手中掌握着关于B间谍的犯罪证据,则称A可以揭发B。有些间谍收受贿赂,只要给他们一定数量的美元,他们就愿意交出手中掌握的全部情报。所以,如果我们能够收买一些间谍的话,我们就可能控制间谍网中的每一分子。因为一旦我们逮捕了一个间谍,他手中掌握的情报都将归我们所有,这样就有可能逮捕新的间谍,掌握新的情报。 我们的反间谍机关提供了一份资料,色括所有已知的受贿的间谍,以及他们愿意收受的具体数额。同时我们还知道哪些间谍手中具体掌握了哪些间谍的资料。假设总共有n个间谍(n不超过3000),每个间谍分别用13000的整数来标识。 请根据这份资料,判断我们是否有可能控制全部的间谍,如果可以,求出我们所需要支付的最少资金。否则,输出不能被控制的一个间谍。</span>

<span style="color:#333333;font-family:"font-size:14px;background-color:#EEEEEE;">输入文件age.in第一行只有一个整数n。 第二行是整数p。表示愿意被收买的人数,1≤p≤n。 接下来的p行,每行有两个整数, 第一个数是一个愿意被收买的间谍的编号, 第二个数表示他将会被收买的数额。这个数额不超过20000。 紧跟着一行只有一个整数r1≤r≤8000。然后r行, 每行两个正整数,表示数对(A, B)A间谍掌握B间谍的证据。</span>

<span style="color:#333333;font-family:"font-size:14px;background-color:#EEEEEE;">如果可以控制所有间谍,第一行输出YES, 并在第二行输出所需要支付的贿金最小值。否则输出NO,并在第二行输出不能控制的间谍中,编号最小的间谍编号。</span>

3 2 1 10 2 100 2 1 3 2 3

YES 110

0

 

【培训习题.图】5.4AGE间谍网络

2017-04-16 08:46:42

1

128

N

1

2

0

1207

【培训习题.图】5.5guards宫廷守卫

从前有一个王国,这个王国的城堡是一个矩形,被分为M×N个方格。一些方格是墙,而另一些是空地。这个王国的国王在城堡里设了一些陷阱,每个陷阱占据一块空地。 一天,国王决定在城堡里布置守卫,他希望安排尽量多的守卫。守卫们都是经过严格训练的,所以一旦他们发现同行或同列中有人的话,他们立即向那人射击。因此,国王希望能够合理地布置守卫,使他们互相之间不能看见,这样他们就不可能互相射击了。守卫们只能被布置在空地上,不能被布置在陷阱或墙上,且一块空地只能布置一个守卫。如果两个守卫在同一行或同一列,并且他们之间没有墙的话,他们就能互相看见。(守卫就像象棋里的车一样) 你的任务是写一个程序,根据给定的城堡,计算最多可布置多少个守卫,并设计出布置的方案。

第一行两个整数MN(1≤MN≤200),表示城堡的规模。 接下来MN列的整数,描述的是城堡的地形。第ij列的数用ai,j表示。 ai,j=0,表示方格[i,j]是一块空地; ai,j=1,表示方格[i,j]是一个陷阱; ai,j=2,表示方格[i,j]是墙。

第一行一个整数K,表示最多可布置K个守卫。 此后K行,每行两个整数xiyi,描述一个守卫的位置。

guards.in 3 4 2 0 0 0 2 2 2 1 0 1 0 2

guards.out 2 1 2 3 3

0

样例数据如图5-2(黑色方格为墙,白色方格为空地,圆圈为陷阱,G表示守卫) <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1207.gif >

【培训习题.图】5.5guards宫廷守卫

2017-04-07 12:40:23

1

64

N

0

0

0

1203

【培训习题.图】5.1 hospital医院设置

设有一棵二叉树,如图5-1 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1203.gif > 其中,圈中的数字表示结点中居民的人口。圈边上数字表示结点编号,现在要求在某个结点上建立一个医院,使所有居民所走的路程之和为最小,同时约定,相邻接点之间的距离为l。如上图中,若医院建在:

第一行一个整数n,表示树的结点数。(n≤100) 接下来的n行每行描述了一个结点的状况,包含三个整数,整数之间用空格(一个或多个)分隔, 其中:第一个数为居民人口数;第二个数为左链接,为0表示无链接;第三个数为右链接。

一个整数,表示最小距离和。

hospital.in 5 13 2 3 4 0 0 12 4 5 20 0 0 40 0 0

hospital.out 81

0

 

【培训习题.图】5.1 hospital医院设置

2017-03-25 20:41:55

1

64

N

8

12

0

1204

【培训习题.图】5.2work工程规划

造一幢大楼是一项艰巨的工程,它是由n个子任务构成的,给它们分别编号12n(5≤n≤1000)。由于对一些任务的起始条件有着严格的限制,所以每个任务的起始时间T1T2Tn并不是很容易确定的(但这些起始时间都是非负整数,因为它们必须在整个工程开始后启动)。例如:挖掘完成后,紧接着就要打地基;但是混凝土浇筑完成后,却要等待一段时间再去掉模板。 这种要求就可以用M(5≤m≤5000)个不等式表示,不等式形如Ti-Tj≤b代表ij的起始时间必须满足的条件。每个不等式的右边都是一个常数b,这些常数可能不相同,但是它们都在区间(-100100)内。 你的任务就是写一个程序,给定像上面那样的不等式,找出一种可能的起始时间序列T1T2 Tn,或者判断问题无解。对于有解的情况,要使最早进行的那个任务和整个工程的起始时间相同,也就是说,T1T2Tn中至少有一个为0

第一行是用空格隔开的两个正整数nm, 下面的m行每行有三个用空格隔开的整数ijb对应着不等式Ti-Tj≤b

如果有可行的方案,那么输出N行,每行都有一个非负整数且至少有一个为0,按顺序表示每个任务的起始时间。 如果没有可行的方案,就输出信息“NO SOLUTION”

work1.in 5 8 1 2 0 1 5 -1 2 5 1 3 1 5 4 1 4 4 3 -1 5 3 -1 5 4 -3 work2.in 5 5 1 2 -3 1 5 -1 2 5 -1 5 1 -5 4 1 4

work1.out 0 2 5 4 1 work2.out NO SOLUTION

0

 

【培训习题.图】5.2work工程规划

2017-03-25 20:41:55

1

64

N

10

30

0

1205

【培训习题.图】5.3servers服务器储存信息

Byteland王国准备在各服务器间建立大型网络并提供多种服务。 网络由n台服务器组成,用双向的线连接。两台服务器之间最多只能有一条线直接连接,同时,每台服务器最多只能和10台服务器直接连接,但是任意两台服务器间必然存在一条路径将它们连接在一起。每条传输线都有一个固定传输的速度。δ(V, W)表示服务器VW之间的最短路径长度,且对任意的Vδ(V, V)0。 有些服务器比别的服务器提供更多的服务,它们的重要程度要高一些。我们用r(V)表示服务器V的重要程度(rank)rank越高的服务器越重要。 每台服务器都会存储它附近的服务器的信息。当然,不是所有服务器的信息都存,只有感兴趣的服务器信息才会被存储。服务器V对服务器W感兴趣是指,不存在服务器U满足,r(U)>r(W)δ(V, U)<=δ(V, W)。 举个例子来说,所有具有最高rank的服务器都会被别的服务器感兴趣。如果V是一台具有最高rank的服务器,由于δ(V, V)0,所以V只对具有最高rank的服务器感兴趣。我们定义B(V)V感兴趣的服务器的集合。 我们希望计算所有服务器储存的信息量,即所有服务器的|B(V)|之和。Byteland王国并不希望存储大量的数据,所以所有服务器存储的数据量(|B(V)|之和)不会超过30n。 你的任务是写一个程序,读入Byteland王国的网络分布,计算所有服务器存储的数据量。

第一行两个整数nm(1≤n≤300001≤m≤5n) n表示服务器的数量,m表示传输线的数量。 接下来n行,每行一个整数,第i行的整数为r(i)(1≤r(i)≤10),表示第i台服务器的rank。 接下来m行,每行表示各条传输线的信息,包含三个整数abt(1≤t≤10001≤ab≤na≠b) ab是传榆线所连接的两台服务器的编号,t是传输线的长度。

一个整数,表示所有服务器存储的数据总量,即|B(V)|之和。

servers.in 4 3 2 3 1 1 1 4 30 2 3 20 3 4 20

servers.out 9

0

 

【培训习题.图】5.3servers服务器储存信息问题

2018-05-20 15:23:56

1

64

N

2

4

0

1208

【培训习题.图】5.6kleague K-联赛

K-联赛职业足球俱乐部的球迷们都是有组织的训练有素的啦啦队员,就像红魔啦啦队一样(2002年韩日世界杯上韩国队的啦啦队)。这个赛季,经过很多场比赛以后,球迷们希望知道他们支持的球队是否还有机会赢得最后的联赛冠军。换句话说,球队是否可以通过某种特定的比赛结果最终取得最高的积分(获胜场次最多)(允许出现多支队并列第一的情况。) 现在,给出每个队的胜负场数,widi,分别表示teami的胜场和负场(1≤i≤n)。还给出ai,j,表示teamiteamj之间还剩多少场比赛要进行(1≤i,j≤n)。这里,n表示参加联赛的队数,所有的队分别用12n来编号。你的任务是找出所有还有可能获得冠军的球队。 所有队参加的比赛数是相同的,并且为了简化问题,你可以认为不存在平局(比赛结果只有胜或负两种)

第一行一个整数n(1≤n≤25),表示联赛中的队数。 第二行2n个数,w1d1w2d2……wndn,所有的数不超过100。 第三行n2个数,a1,1a1,2a1,na2,1a2,2a2,nan,1an,2an,n,所有的数都不超过10ai,j=aj,i,如果i=j,则ai,j=0

仅一行,输出所有可能获得冠军的球队,按其编号升序输出,中间用空格分隔。

kleague1.in 3 2 0 1 1 0 2 0 2 2 2 0 2 2 2 0 kleague2.in 3 4 0 2 2 0 4 0 1 1 1 0 1 1 1 0 kleague3.in 4 0 3 3 1 1 3 3 0 0 0 0 2 0 0 1 0 0 1 0 0 2 0 0 0

kleague1.out 1 2 3 kleague2.out 1 2 kleague3.out 2 4

0

 

【培训习题.图】5.6kleague K-联赛

2017-04-07 12:40:36

1

64

N

0

0

0

1209

【培训习题.图】5.7machine机器调度

我们知道机器调度是计算机科学中一个非常经典的问题。调度问题有很多种,具体条件不同,问题就不同。现在我们要处理的是两个机器的调度问题。 有两个机器AB。机器An种工作模式,我们称之为mode_0mode_l……mode_n-1。同样,机器Bm种工作模式,我们称之为mode_0mode_1,……mode_m-1。初始时,两台机器的工作模式均为mode_0。现在有k个任务,每个工作都可以在两台机器中任意一台的特定的模式下被加工。例如,job0能在机器Amode_3或机器Bmode_4下被加工,jobl能在机器Amode_2或机器Bmode_4下被加工,等等。因此,对于任意的jobi,我们可以用三元组(i,x,y)来表示jobi在机器Amode_x或机器Bmode_y下被加工。 显然,要完成所有工作,我们需要不时的改变机器的工作模式。但是,改变机器的工作状态就必须重启机器,这是需要代价的。你的任务是,合理的分配任务给适当的机器,使机器的重启次数尽量少。

第一行三个整数nmn,m<100),kk<1000)。接下来的k行,每行三个整数i,x,y

只一行一个整数,表示最少的重启次数。

machine.in 5 5 10 0 1 1 1 1 2 2 1 3 3 1 4 4 2 1 5 2 2 6 2 3 7 2 4 8 3 3 9 4 3

machine.out 3

0

 

【培训习题.图】5.7machine机器调度

2017-04-07 12:40:48

1

64

N

0

0

0

1210

【培训习题.图】5.8road公路修建

某国有n个城市,它们互相之间没有公路相通,因此交通十分不便。为解决这一行路难的问题,政府决定修建公路。修建公路的任务由各城市共同完成。 修建工程分若干轮完成。在每一轮中,每个城市选择一个与它最近的城市,申请修建通往该城市的公路。政府负责审批这些申请以决定是否同意修建。 政府审批的规则如下: (1)如果两个或以上城市申请修建同一条公路,则让它们共同修建; (2)如果三个或以上的城市申请修建的公路成环。如下图,A申请修建公路ABB申请修建公路BCC申请修建公路CA。则政府将否决其中最短的一条公路的修建申请; <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1210a.gif > 3)其他情况的申请一律同意。 一轮修建结束后,可能会有若干城市可以通过公路直接或间接相连。这些可以互相:连通的城市即组成城市联盟。在下一轮修建中,每个城市联盟将被看作一个城市,发挥一个城市的作用。 当所有城市被组合成一个城市联盟时,修建工程也就完成了。 你的任务是根据城市的分布和前面讲到的规则,计算出将要修建的公路总长度。

第一行一个整数n,表示城市的数量。(n≤5000) 以下n行,每行两个整数xy,表示一个城市的坐标。(-1000000≤xy≤1000000)

一个实数,四舍五入保留两位小数,表示公路总长。(保证有惟一解)

road.in 4 0 0 1 2 -1 2 0 4

road.out 6.47

0

修建的公路如图所示: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1210b.gif >

【培训习题.图】5.8road公路修建

2017-04-07 12:43:04

1

64

N

0

0

0

1211

【培训习题.图】5.9speed速度限制

在这个繁忙的社会中,我们往往不再去选择最短的道路,而是选择最快的路线。开车时每条道路的限速成为最关键的问题。不幸的是,有一些限速的标志丢失了,因此你无法得知应该开多快。一种可以辩解的解决方案是,按照原来的速度行驶。你的任务是计算两地间的最快路线。 你将获得一份现代化城市的道路交通信息。为了使问题简化,地图只包括路口和道路。每条道路是有向的,只连接了两条道路,并且最多只有一块限速标志,位于路的起点。两地AB,最多只有一条道路从A连接到B。你可以假设加速能够在瞬间完成并且不会有交通堵塞等情况影响你。当然,你的车速不能超过当前的速度限制。

输入文件SPEED.IN的第一行是3个整数NMD(2<N<=150),表示道路的数目,用0..N-1标记。 M是道路的总数,D表示你的目的地。 接下来的M行,每行描述一条道路,每行有4个整数A(0≤A<N)B(0≤B<N)V(0≤V≤500)and L(1≤L≤500),这条路是从AB的, 速度限制是V,长度为L。 如果V0,表示这条路的限速未知。 如果V不为0,则经过该路的时间T=L/V。否则T=L/VoldVold是你到达该路口前的速度。 开始时你位于0点,并且速度为70

输出文件SPEED.OUT仅一行整数,表示从0D经过的城市。 输出的顺序必须按照你经过这些城市的顺序,以0开始,以D结束。仅有一条最快路线。

speed.in 6 15 1 0 1 25 68 0 2 30 50 0 5 0 101 1 2 70 77 1 3 35 42 2 0 0 22 2 1 40 86 2 3 0 23 2 4 45 40 3 1 64 14 3 5 0 23 4 1 95 8 5 1 0 84 5 2 90 64 5 3 36 40

speed.out 0 5 2 3 1

0

 

【培训习题.图】5.9speed速度限制

2017-04-07 13:02:07

1

64

N

0

0

0

1212

【培训习题.树】6.1tree排序二叉树

一个边长为n的正三角形可以被划分成若干个小的边长为1的正三角形,称为单位三角形。如右图,边长为3的正三角形被分成三层共9个小的正三角形,我们把它们从顶到底,从左到右以19编号,见右图。同理,边长为n的正三角形可以划分成n2个单位三角形。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1212/p1212a.gif > 四个这样的边长为n的正三角形可以组成一个三棱锥。我们将正三棱锥的三个侧面依顺时针次序(从顶向底视角)编号为A, B, C,底面编号为D。侧面的A, B, C号三角形以三棱锥的顶点为顶,底面的D号三角形以它与AB三角形的交点为顶。左图为三棱锥展开后的平面图,每个面上标有圆点的是该面的顶,该图中侧面A, B, C分别向纸内方向折叠即可还原成三棱锥。我们把这ABCD四个面各自划分成n2个单位三角形。

输入文件为tree.in。其中第一行是一个整数n(1<=n<=18),随后的4 n<sup>2</sup>个数,依次为三棱锥四个面上所填的数字。

输出文件为tree.out。其中仅包含一个整数,表示最大的排序二又树所含的节点数目。

输入文件对应下图: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1212/p1212b.gif > tree.in 3 22 13 9 19 25 15 1 33 20 26 28 32 21 18 7 31 12 17 2 29 24 8 6 3 23 16 36 5 34 27 4 35 11 30 14 10

输出样例文件对应的最大排序二叉树如下图所示: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1212/p1212c.gif > tree.out 17

0

 

【培训习题.树】6.1tree排序二叉树

2017-04-07 13:02:07

1

64

N

0

1

0

1213

【培训习题.树】6.2weight树的重量

树可以用来表示物种之间的进化关系。一棵进化树是一个带边权的树,其叶节点表示一个物种,两个叶节点之间的距离表示两个物种的差异。现在,一个重要的问题是,根据物种之间的距离,重构相应的进化树。 令N={1..n},用一个N上的矩阵M来定义树T。其中,矩阵M满足:对于任意的ijk,有M[i,j]+M[j,k]<=M[i,k]。树T满足: 1.叶节点属于集合N 2.边权均为非负整数; 3dT(i,j)=M[i,j],其中dT(i,j)表示树上ij的最短路径长度。 如下图,矩阵M描述了一棵树。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1213/p1213a.gif > 树的重量是指树上所有边权之和。对于任意给出的合法矩阵M,它所能表示树的重量是惟一确定的,不可能找到两棵不同重量的树,它们都符合矩阵M。你的任务就是,根据给出的矩阵M,计算M所表示树的重量。下图是上面给出的矩阵M所能表示的一棵树,这棵树的总重量为15 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1213/p1213b.gif >

输入数据包含若干组数据。每组数据的第一行是一个整数n(2<n<30)。其后n-l行,给出的是矩阵M的一个上三角(不包含对角线),矩阵中所有元素是不超过100的非负整数。输入数据保证合法。 输入数据以n=0结尾。

对于每组输入,输出一行,一个整数,表示树的重量。

weight.in 5 5 9 12 8 8 11 7 5 1 4 4 15 36 60 31 55 36 0

weight.out 15 71

0

 

【培训习题.树】6.2weight树的重量

2017-04-07 13:02:07

1

64

N

0

0

0

1214

【培训习题.树】6.3booster信号放大器

树型网络是最节省材料的网络。所谓树型网络,是指一个无环的连通网络,网络中任意两个结点间有且仅有一条通信道路。 网络中有一个结点是服务器,负责将信号直接或间接地发送到各终端机。如图6-4server结点发出一个信号给结点aca再转发给b。如此,整个网络都收到这个信号了。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1214a.gif > 但是,实际操作中,信号从一个结点发到另一个结点,会出现信号强度的衰减。衰减量一般由线路长度决定。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1214b.gif > 如上图,边上所标的数字为边的衰减量。假设从server出发一个强度为4个单位的信号,发到结点a后强度衰减为4-3=1个单位。结点a再将其转发给结点b。由于信号强度为1,衰减量为2,因此信号无法发送到b。 一个解决这一问题的方法是,安装信号放大器。信号放大器的作用是将强度大于零的信号还原成初始强度(从服务器出发时的强度)。 上图中,若在结点a处安装一个信号放大器,则强度为4的信号发到a处,即被放大至4。这样,信号就可以被发送的网络中的任意一个节点了。为了简化问题,我们假定每个结点只处理一次信号,当它第二次收到某个信号时,就忽略此信号。 你的任务是根据给出的树型网络,计算出最少需要安装的信号放大器数量。

第一行一个整数n,表示网络中结点的数量。(n<=100000) 第2--n+1行,每行描述一个节点的连接关系。其中第i+1行,描述的是结点i的连接关系:首先一个整数k,表示与结点i相连的结点的数量。此后2k个数,每两个描述一个与结点i相连的结点,分别表示结点的编号(编号在1~n之间)和该结点与结点i之间的边的信号衰减量。结点1表示服务器。 最后一行,一个整数,表示从服务器上出发信号的强度。

一个整数,表示要使信号能够传遍整个网络,需要安装的最少的信号放大器数量。 如果不论如何安装信号放大器,都无法使信号传遍整个网络,则输出“No solution.”

booster.in 4 2 2 3 3 1 2 1 3 4 2 1 1 1 1 2 2 4

booster.out 1

0

 

【培训习题.树】6.3booster信号放大器

2017-04-07 13:02:07

1

64

N

0

0

0

1215

【培训习题.树】6.4gallery“访问术馆

经过数月的精心准备,Peer Brelstet,一个出了名的盗画者,准备开始他的下一个行动。艺术馆的结构,每条走廊要么分叉为两条走廊,要么通向一个展览室。Peer知道每个展室里藏画的数量,并且他精确测量了通过每条走廊的时间。由于经验老到,他拿下一幅画需要5秒的时间。你的任务是编一个程序,计算在警察赶来之前,他最多能偷到多少幅画。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1215.gif >

1行是警察赶到的时间,以s为单位。第2行描述了艺术馆的结构,是一串非负整数,成对地出现:每一对的第一个数是走过一条走廊的时间,第2个数是它末端的藏画数量;如果第2个数是0,那么说明这条走廊分叉为两条另外的走廊。数据按照深度优先的次序给出,请看样例。 一个展室最多有20幅画。通过每个走廊的时间不超过20s。艺术馆最多有100个展室。警察赶到的时间在10min以内。

输出偷到的画的数量。

gallery.in(如图6-6 60 7 0 8 0 3 1 14 2 10 0 12 4 6 2

gallery.out 2

0

 

【培训习题.树】6.4gallery“访问术馆

2017-04-07 13:02:07

1

64

N

0

1

0

1216

【培训习题.树】6.5party聚会的快乐

你要组织一个由你公司的人参加的聚会。你希望聚会非常愉快,尽可能多地找些有趣的热闹。但是劝你不要同时邀请某个人和他的上司,因为这可能带来争吵。给定N个人(姓名,他幽默的系数,以及他上司的名字),编程找到能使幽默系数和最大的若干个人。

第一行一个整数N(N<100)。接下来有N行,每一行描述一个人的信息,信息之间用空格隔开。 姓名是长度不超过20的字符串,幽默系数是在0100之间的整数。

所邀请的人最大的幽默系数和。

party.in 5 BART 1 HOMER HOMER 2 MONTGOMERY MONTGOMERY 1 NOBODY LISA 3 HOMER SMITHERS 4 MONTGOMERY

party.out 8

0

 

【培训习题.树】6.5party聚会的快乐

2017-04-13 16:33:05

1

64

N

0

2

0

1217

【培训习题.树】6.6roads重建道路

一场可怕的地震后,人们用N个牲口棚(1≤N≤150,编号1..N)重建了农夫John的牧场。由于人们没有时间建设多余的道路,所以现在从一个牲口棚到另一个牲口棚的道路是惟一的。因此,牧场运输系统可以被构建成一棵树。John想要知道另一次地震会造成多严重的破坏。有些道路一旦被毁坏,就会使一棵含有P(1≤P≤N)个牲口棚的子树和剩余的牲口棚分离,John想知道这些道路的最小数目。

1行:2个整数,NP 2..N行:每行2个整数IJ,表示节点I是节点J的父节点。

单独一行,包含一旦被破坏将分离出恰含P个节点的子树的道路的最小数目。

roads.in 11 6 1 2 1 3 1 4 1 5 2 6 2 7 2 8 4 9 4 10 4 11

roads.out 2

0

【样例解释】 如果道路1-41-5被破坏,含有节点(123678)的子树将被分离出来

【培训习题.树】6.6roads重建道路

2017-04-13 16:33:05

1

64

N

0

1

0

1218

【培训习题.树】6.7tele有线电视网

某收费有线电视网计划转播一场重要的足球比赛。他们的转播网和用户终端构成一棵树状结构,这棵树的根结点位于足球比赛的现场,树叶为各个用户终端,其他中转站为该树的内部节点。 从转播站到转播站以及从转播站到所有用户终端的信号传输费用都是已知的,一场转播的总费用等于传输信号的费用总和。 现在每个用户都准备了一笔费用想观看这场精彩的足球比赛,有线电视网有权决定给哪些用户提供信号而不给哪些用户提供信号。 写一个程序找出一个方案使得有线电视网在不亏本的情况下使观看转播的用户尽可能多。

输入文件的第一行包含两个用空格隔开的整数NM,其中2≤N≤30001≤M≤N-1N为整个有线电视网的结点总数,M为用户终端的数量。 第一个转播站即树的根结点编号为1,其他的转播站编号为2N-M,用户终端编号为N-M+1N。 接下来的N-M行每行表示个转播站的数据,第i+1行表示第i个转播站的数据,其格式如下: K A1 C1 A2 C2 … Ak Ck K表示该转播站下接K个结点(转播站或用户),每个结点对应一对整数ACA表示结点编号,C表示从当前转播站传输信号到结点A的费用。最后一行依次表示所有用户为观看比赛而准备支付的钱数。

输出文件仅一行,包含一个整数,表示上述问题所要求的最大用户数。

tele.in 5 3 2 2 2 5 3 2 3 2 4 3 3 4 2

tele.out 2

0

如下图所示,共有五个结点。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1218.gif > 结点为根结点,即现场直播站, 为一个中转站, ③④⑤为用户端,共M个,编号从N-M+1N,他们为观看比赛分别准备的钱数为342, 从结点可以传送信号到结点,费用为2,也可以传送信号到结点,费用为3(第二行数据所示), 从结点可以传输信号到结点,费用为2。也可传输信号到结点,费用为3(第三行数据所示), 如果要让所有用户(③④⑤)都能看上比赛,则信号传输的总费用为:2+3+2+3=10,大于用户愿意支付的总费用3+4+2=9,有线电视网就亏本了,而只让③④两个用户看比赛就不亏本了。

【培训习题.树】6.7tele有线电视网

2017-04-13 16:33:05

1

64

N

0

1

0

1219

【培训习题.搜索】7.1divisors最多因子数

数学家们喜欢各种类型的有奇怪特性的数。例如,他们认为945是一个有趣的数,因为它是第一个所有约数之和大于本身的奇数。 为了帮助他们寻找有趣的数,你将写一个程序扫描一定范围内的数,并确定在此范围内约数个数最多的那个数。不幸的是,这个数和给定的范围的都比较大,用简单的方法寻找可能需要较多的运行时间。所以请确定你的算法能在几秒内完成最大范围内的扫描。

只有一行,给出扫描的范围,由下界L和上界U确定。满足2≤L≤U≤1000000000

对于给定的范围,输出该范围内约数个数D最多的数P。 若有多个,则输出最小的那个。 请输出“Between L and UP has a maximum of D divisors,其中LUPD的含义同前面所述。

divisors.in 1000 2000

divisors.out Between 1000 and 2000, 1680 has a maximum of 40 divisors.

0

【知识准备】 深度优先搜索的基本实现方法及剪枝的基本概念。

【培训习题.搜索】7.1divisors最多因子数

2017-04-13 16:33:05

1

64

N

1

6

0

1220

【培训习题.搜索】7.2game黑白棋游戏

黑白棋游戏的棋盘由4×4方格阵列构成。棋盘的每一方格中放有1枚棋子,共有8枚白棋子和8枚黑棋子。这16枚棋子的每一种放置方案都构成一个游戏状态。在棋盘上拥有1条公共边的2个方格称为相邻方格。一个方格最多可有4个相邻方格。 在玩黑白棋游戏时,每一步可将任何2个相邻方格中棋子互换位置。对于给定的初始游戏状态和目标游戏状态,编程计算从初始游戏状态变化到目标游戏状态的最短着棋序列。

输入文件共有8行。前四行是初始游戏状态,后四行是目标游戏状态。 每行4个数分别表示该行放置的棋子颜色。“0”表示白棋;“1”表示黑棋。

输出文件的第一行是着棋步数n。 接下来n行,每行4个数分别表示该步交换棋子的两个相邻方格的位置。 例如,abcd表示将棋盘上(ab)处的棋子与(cd)处的棋子换位。

game.in 1111 0000 1110 0010 1010 0101 1010 0101

game.out 4 1222 1424 3242 4344

0

 

【培训习题.搜索】7.2game黑白棋游戏

2017-04-13 16:33:05

1

64

N

1

4

0

1221

【培训习题.搜索】7.3puzzle纵横填字游戏

这个题目要求你编写一个程序来解决一个纵横填字游戏。 这个游戏比我们在报纸上见到的通常的填字游戏要简单。游戏仅给出单词的起始位置,方面(横向或纵向)以及单词的长度。只要单词的长度正好,游戏中能填入任何一个来自词典的单词。 在游戏中单词相交处的字母必须相同,当然,任何单词只准使用一次。 思考一下以下这个游戏。 例如,假定从上到下有5行,用04来表示,从左到右有5列,用04来表示。我们用(X, Y)来表示填字游戏中第X列和第Y行的字母。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1221.gif > 在这个游戏中,我们需填入5个单词:在(0, 0)的右边填入一个4个字母的单词,在(0, 0)的下方填入一个4个字母的单词,在(2, 0)的下方填入一个4个字母的单词,在(0, 2)的右边填入一个3个字母的单词,最后在(2, 3)的右边填入一个3个字母的单词。字典上所有的单词都能使用但最多只能使用一次。例如,以下是一个可能的解决方案。 (0, 0)右边,LATE 0, 0)下面,LIED 2, 0)下面,TELL 2, 3)右边,LOW

输入文件的第一行是作为字典使用的个文本文件名,你可以假定这个文件存在,是可读的并且包含最多不超过100000个单词,并且按词典顺序存储,每行一个单词。 字典中所有的单词所含的字母可以是大写或小写(在这个问题中字母的大小写是无关紧要的)。你可以假设字典中所有单词的长度不超过20个字符。 输入文件的下一行包含一个整数n(n≤15),表示要填的单词的数量。 接下来的n行中每行给出关于一个单词的提示,在每个提示中分别给出单词的首字母在填字游戏中的列和行的位置,后面根据单词的方向是横向还是纵向,相应跟字符A或字符D,最后一个数表示该单词的长度,以上数据之间均用空格隔开。 你能作以下的进一步的假设。 (1)填字游戏的尺寸不超过10×10。 (2)游戏盘中放得下所有的单词。 (3)用给定的词典是能够破解出该游戏的。

输出文件应该包含n行,输出游戏中可填入的所有单词。单词应该每行出现一个,并且按输入文件中提示的顺序输出。 每个单词中所有的字母必须是大写的。所有的单词必须来自给定的词典文件(忽略大小写)。任何单词只能使用一次。 对于给定输入文件可能有大量的正确解决方案,你只须输出其中的任意一个解决方案。

puzzle.in words.txt 5 0 0 A 4 0 0 D 4 2 0 D 4 0 2 A 3 2 3 A 3

puzzle.out LATE LIED TELL EEL LOW

0

【知识准备】 (1)深度优先搜索的基本实现方法; (2Hash表的基本理论及其实现方法(主要是吊桶处理冲突法)。

【培训习题.搜索】7.3puzzle纵横填字游戏

2017-04-13 16:48:21

1

64

N

0

0

0

1222

【培训习题.搜索】7.4magic魔术数字游戏

填数字方格的游戏有很多种变化,如下图所示的4×4方格中,我们要选择从数字116来填满这十六个格子(Aij,其中i1..4j1..4)。为了让游戏更有挑战性,我们要求下列六项中的每一项所指定的四个格子,其数字累加的和必须为34: 四个角落上的数字,即A11+A14+A41+A4434。 每个角落上的2×2方格中的数字,例如左上角:A11+A12+A21+A2234。 最中间的2×2方格中的数字,即A22+A23+A32+A33=34。 每条水平线上四个格子中的数字,即Ai1+Ai2+Ai3+Ai434,其中i1..4。 每条垂直线上四个格子中的数字,即A1j+A2j+A3j+A4j34,其中j1..4。 两条对角线上四个格子中的数字,例如左上角到右下角:A11+A22+A33+A4434。 右上角到左下角:A14+A23+A32+A4134 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1222.gif >

输入文件会指定把数字1先固定在某一格内。 输入的文件只有一行包含两个正数据IJ,表示第1行和第J列的格子放数字1。 剩下的十五个格子,请按照前述六项条件用数字216来填满。

把全部的正确解答用每4行一组写到输出文件,每行四个数,相邻两数之间用一个空格隔开。 两组答案之间,要以一个空白行相间,并且依序排好。 排序的方式,是先从第一行的数字开始比较,每一行数字,由最左边的数字开始比,数字较小的解答必须先输出到文件中。

magic.in 1 1

magic.out 1 4 13 16 14 15 2 3 8 5 12 9 11 10 7 6 1 4 13 16 14 15 2 3 12 9 8 5 7 6 11 10

0

 

【培训习题.搜索】7.4magic魔术数字游戏

2017-04-13 16:48:21

30

64

N

0

1

0

1223

【培训习题.搜索】7.5panel魔板

有这样一种魔板:它是一个长方形的面板,被划分成nm列的n*m个方格。每个方格内有一个小灯泡,灯泡的状态有两种(亮或暗)。我们可以通过若干操作使魔板从一个状态改变为另一个状态。操作的方式有两种: (1)任选一行,改变该行中所有灯泡的状态,即亮的变暗、暗的变亮; (2)任选两列,交换其位置。 当然并不是任意的两种状态都可以通过若干操作来实现互相转化的。 你的任务就是根据给定两个魔板状态,判断两个状态能否互相转化。

文件中包含多组数据。第一行一个整数k,表示有k组数据。 每组数据的第一行两个整数nm(0<nm≤100) 以下的n行描述第一个魔板。每行有m个数字(01),中间用空格分隔。若第x行的第y个数字为0,则表示魔板的第xy列的灯泡为;否则为。 然后的n行描述第二个魔板。数据格式同上。 任意两组数据间没有空行。

k行,依次描述每一组数据的结果。 若两个魔板可以相互转化,则输出YES,否则输出NO(注意:请使用大写字母)

panel.in 2 3 4 0 1 0 1 1 0 0 1 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 2 2 0 0 0 1 1 1 1 1

panel.out YES NO

0

 

【培训习题.搜索】7.5panel魔板

2017-04-13 16:48:21

1

64

N

0

1

0

1224

【培训习题.搜索】7.6scan三维扫描

工业和医学上经常要用到一种诊断技术——核磁共振成像(Magnetic Resonance Imagers)。利用该技术可以对三维物体(例如大脑)进行扫描。扫描的结果用一个三维的数组来保存,数组的每一个元素表示空间的一个像素。数组的元素是0~255的整数,表示该像素的灰度。例如0表示该像素是黑色的,255表示该像素是白色的。 被扫描的物体往往是由若干个部件组合而成的。例如临床医学要对病变的器官进行检查,而器官是由一些不同的组织构成的。在实际问题中,同一个部件内部的色彩变化相对连续,而不同的部件的交界处色彩往往有突变。下图是一个简化的植物细胞的例子。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1224.gif > 从细胞的平面图来看,该细胞大致是由四个部件构成的,细胞壁、细胞核、液泡和细胞质。为了方便起见,我们对部件的概念做如下的规定: (1)如果一个像素属于某部件,则或者该像素至少与该部件的一个像素相邻,或者该像素单独组成一个部件。(说明:每一个像素与前后、左右、上下的6个像素相邻) 2)同一个部件内部,相邻两个像素的灰度差不超过正整数MM决定了程序识别部件的灵敏度。 请你编一个程序,对于给定的物体,判断该物体是由几个部件组成的。

第一行是三个正整数LWH(LWH≤50),表示物体的长、宽、高。 第二行是一个整数M(0≤M≤255),表示识别部件的灵敏度。 接下来是L×W×HO~255的非负整数,按照空间坐标从小到大的顺序依次给出每个像素的灰度。 说明:对于空间两点P1(x1, y1, z1)P2(x2, y2, z2)P1<P2当切仅当 (x1<x2)或者(x1=x2y1<y2)或者(x1=x2y1=y2z1<z2s

一个整数N,表示一共识别出几个部件。

scan.in 2 2 2 0 1 1 1 1 2 2 2 2

scan.out 2

0

 

【培训习题.搜索】7.6scan三维扫描

2017-04-13 16:48:21

1

64

N

0

0

0

1225

【培训习题.搜索】7.7scrabble拼字游戏

有一个未知的4×4的拼盘M,它的每个元素都是正整数。给出4行元素的总和,4列元素的总和以及两条对角线元素总和。另外还给出了拼盘中任意4个位置的元素值,它们的位置在输入文件中给定。 编写一个程序求出拼盘中另外12个位置的正整数的值,要求这些元素的行之和,列之和以及对角线之和与输入文件中给定的值相一致。

输入文件包含用空格隔开的22个正整数。 前四个数字分别表示四行中每一行元素的总和,接下来的4个数字分别表示4列中每列元素的总和。接下来的数字表示主对角线元素的总和,即M(0, 0)+M(1,1)+M(2, 2)+M(3, 3)。然后的数字(10个数字)表示逆对角线上元数之和,即M(0, 3)+M(1, 2)+M(2, 1)+M(3, 0)。剩下的部分还包含12个数字,被分成三个一组的形式ijk。表示M(i,j)=k。 你可以假设任何行对角线或列之和不会超过300。另外还可假设对于给定的输入文件总是存在解决方案。

输出文件应包含按4×4的形式输出的16个数字,同一行的四个数字用一个空个隔开。 注意:对于给定的输入文件,可能有一个以上可能的解决方案。任何一个方案都是可接受的。

scrabble.in 130 120 172 140 157 93 144 168 66 195 0 1 15 1 3 49 2 2 16 3 0 33

scrabble.out 22 15 28 65 49 1 21 49 53 76 16 27 33 1 79 27

0

 

【培训习题.搜索】7.7scrabble拼字游戏

2017-04-13 16:48:21

1

64

N

0

1

0

1226

【培训习题.搜索】7.8stick小木棍

乔治有一些同样长的小木棍,他把这些木棍随意砍成几段,直到每段的长都不超过50。 现在,他想把小木棍拼接成原来的样子,但是却忘记了自己开始时有多少根木棍和它们的长度。 给出每段小木棍的长度,编程帮他找出原始木棍的最小可能长度。

输入文件共有二行。 第一行为一个单独的整数N表示看过以后的小木柜的总数,其中N≤60, 第二行为N个用空个隔开的正整数,表示N跟小木棍的长度。

输出文件仅一行,表示要求的原始木棍的最小可能长度。

stick.in 9 5 2 1 5 2 1 5 2 1

stick.out 6

0

 

【培训习题.搜索】7.8stick小木棍

2017-04-13 16:48:21

1

64

N

0

2

0

1227

【培训习题.搜索】7.9words单词游戏

IoAo在玩一个单词游戏。 他们轮流说出一个仅包含元音字母的单词,并且后一个单词的第一个字母必须与前一个单词的最后一个字母一致。 游戏可以从任何一个单词开始。 任何单词禁止说两遍,游戏中只能使用给定词典中含有的单词。 游戏的复杂度定义为游戏中所使用的单词长度总和。 编写程序,求出使用一本给定的词典来玩这个游戏所能达到的游戏最大可能复杂度。

输入文件的第一行,表示一个自然数N(1≤N≤16)N表示一本字典中包含的单词数量以下的每一行包含字典中的一个单词, 每一个单词是由字母AEIOU组成的一个字符串, 每个单词的长度将小于等于100,所有的单词是不一样的。

输出文件仅有一行,表示该游戏的最大可能复杂度。

words.in 5 IOO IUUO AI OIOOI AOOI

words.out 16

0

 

【培训习题.搜索】7.9words单词游戏

2017-04-13 16:48:21

1

64

N

0

1

0

1228

【培训习题.动态规划】8.1blast字串距离

设有字符串X,我们称在X的头尾及中间插入任意多个空格后构成的新字符串为X的扩展串,如字符串X”abcbcd”,则字符串“abcb□cd”“□a□bcbcd□”“abcb□cd□”都是X的扩展串,这里“□”代表空格字符。 如果A1是字符串A的扩展串,B1是字符串B的扩展串,A1B1具有相同的长度,那么我扪定义字符串A1B1的距离为相应位置上的字符的距离总和,而两个非空格字符的距离定义为它们的ASCII码的差的绝对值,而空格字符与其他任意字符之间的距离为已知的定值K,空格字符与空格字符的距离为0。在字符串AB的所有扩展串中,必定存在两个等长的扩展串A1B1,使得A1B1之间的距离达到最小,我们将这一距离定义为字符串AB的距离。 请你写一个程序,求出字符串AB的距离。

输入文件第一行为字符串A, 第二行为字符串BAB均由小写字母组成且长度均不超过2000。 第三行为一个整数K1≤K≤100),表示空格与其他字符的距离。

输出文件仅一行包含一个整数,表示所求得字符串AB的距离。

blast.in cmc snmn 2

blast.out 10

0

 

【培训习题.动态规划】8.1blast字串距离

2017-04-13 16:48:21

1

64

N

0

3

0

1229

【培训习题.动态规划】8.2family血缘关系

我们正在研究妖怪家族的血缘关系。每个妖怪都有相同数量的基因,但是不同的妖怪的基因可能是不同的。我们希望知道任意给定的两个妖怪之间究竟有多少相同的基因。由于基因数量相当庞大,直接检测是行不通的。但是,我们知道妖怪家族的家谱,所以我们可以根据家谱来估算两个妖怪之间相同基因的数量。 妖怪之间的基因继承关系相当简单:如果妖怪C是妖怪AB的孩子,则C的任意一个基因只能是继承AB的基因,继承AB的概率各占50%。所有基因可认为是相互独立的,每个基因的继承关系不受别的基因影响。 现在,我们来定义两个妖怪XY的基因相似程度。例如,有一个家族,这个家族中有两个毫无关系(没有相同基因)的妖怪AB,及它们的孩子CD。那么CD相似程度是多少呢?因为CD的基因都来自AB,从概率来说,各占50%。所以,依概率计算CD平均有50%的相同基因,CD的基因相似程度为50%。需要注意的是,如果AB之间存在相同基因的话,CD的基因相似程度就不再是50%了。 你的任务是写一个程序,对于给定的家谱以及成对出现的妖怪,计算它们之间的基因相似程度。

第一行两个整数nkn2≤n≤300)表示家族中成员数,它们分别用1, 2, …, n来表示。k0≤k≤n-2)表示这个家族中有父母的妖怪数量(其他的妖怪没有父母,它们之间可以认为毫无关系,即没有任何相同基因)。 接下来的k行,每行三个整数a, b, c,表示妖怪a是妖怪b的孩子。 然后是一行一个整数m1≤m≤n2),表示需要计算基因相似程度的妖怪对数。 接下来的m行,每行两个整数,表示需要计算基因相似程度的两个妖怪。 你可以认为这里给出的家谱总是合法的。具体来说就是,没有任何的妖怪会成为自己的祖先,并且你也不必担心会存在性别错乱问题。

m行。可k行表示第k对妖怪之间的基因相似程度。你必须按百分比输出,有多少精度就输出多少,但不允许出现多余的0(注意,0.001的情况应输出0.1%,而不是.1%)。具体格式参见样例。

family.in 7 4 4 1 2 5 2 3 6 4 5 7 5 6 4 1 2 2 6 7 5 3 3

family.out 0% 50% 81.25% 100%

0

【知识准备】 (1)基本的概率计算知识; (2)递推原理(包括记忆化搜索)。

【培训习题.动态规划】8.2family血缘关系

2017-04-13 16:48:21

1

64

N

0

0

0

1230

【培训习题.动态规划】8.3lignja尼克的任务

尼克每天上班之前都连接上英特网,接收他的上司发来的邮件,这些邮件包含了尼克主管的部门当天要完成的全部任务,每个任务由一个开始时刻与一个持续时间构成。 尼克的一个工作日为N分钟,从第一分钟开始到第N分钟结束。当尼克到达单位后他就开始干活。如果在同一时刻有多个任务需要完戍,尼克可以任选其中的一个来做,而其余的则由他的同事完成,反之如果只有一个任务,则该任务必需由尼克去完成,假如某些任务开始时刻尼克正在工作,则这些任务也由尼克的同事完成。如果某任务于第P分钟开始,持续时间为T分钟,则该任务将在第P+T-1分钟结束。 写一个程序计算尼克应该如何选取任务,才能获得最大的空暇时间。

输入数据第一行含两个用空格隔开的整数NK(1≤N≤100001≤K≤10000)N表示尼克的工作时间,单位为分钟,K表示任务总数。 接下来共有K行,每一行有两个用空格隔开的整数PT,表示该任务从第P分钟开始,持续时间为T分钟,其中1≤P≤N1≤P+T-1≤N

输出文件仅一行,包含一个整数,表示尼克可能获得的最大空暇时间。

lignja.in 15 6 1 2 1 6 4 11 8 5 8 1 11 5

lignja.out 4

0

 

【培训习题.动态规划】8.3lignja尼克的任务

2017-04-13 16:48:21

1

64

N

0

3

0

1231

【培训习题.动态规划】8.4book书的复制

现在要把m本有顺序的书分给k给人复制(抄写),每一个人的抄写速度都一样,一本书不允许给两个(或以上)的人抄写,分给每一个人的书,必须是连续的,比如不能把第一、第三、第四本书给同一个人抄写。 现在请你设计一种方案,使得复制时间最短。复制时间为抄写页数最多的人用去的时间。

第一行两个整数mk;(k≤m≤500) 第二行m个整数,第i个整数表示第i本书的页数。

k行,每行两个整数,第i行表示第i个人抄写的书的起始编号和终止编号。 k行的起始编号应该从小到大排列,如果有多解,则尽可能让前面的人少抄写。

book.in 9 3 1 2 3 4 5 6 7 8 9

book.out 1 5 6 7 8 9

0

 

【培训习题.动态规划】8.4book书的复制

2017-04-13 16:56:25

1

64

N

0

3

0

1232

【培训习题.动态规划】8.5dom多米诺骨

多米诺骨牌有上下2个方块组成,每个方块中有1~6个点。现有排成行的n个多米诺骨牌如图8-1所示。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1232.gif > 两个方块互换位置。 编程用最少的旋转次数使多米诺骨牌上下2行点数之差达到最小。 对于图8-1中的例子,只要将最后一个多米诺骨牌旋转180°,可使上下2行点数之差为0

输入文件的第一行是一个正整数n(1≤n≤1000),表示多米诺骨牌数。 接下来的n行表示n个多米诺骨牌的点数。每行有两个用空格隔开的正整数,表示多米诺骨牌上下方块中的点数ab,且1≤ab≤6

输出文件仅一行,包含一个整数。表示求得的最小旋转次数。

dom.in 4 6 1 1 5 1 3 1 2

dom.out 1

0

 

【培训习题.动态规划】8.5dom多米诺骨

2017-04-13 16:56:25

1

64

N

0

2

0

1233

【培训习题.动态规划】8.6paint平板涂色

CE数码公司开发了一种名为自动涂色机(APM)的产品。它能用预定的颜色给一块由不同尺寸且互不覆盖的矩形构成的平板涂色。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1233.gif > 为了涂色,APM需要使用一组刷子。每个刷子涂一种不同的颜色CAPM拿起一把有颜色C的刷子,并给所有颜色为C且符合下面限制的矩形涂色: 为了避免颜料渗漏使颜色混合,一个矩形只能在所有紧靠它上方的矩形涂色后,才能涂色。例如图中矩形F必须在CD涂色后才能涂色。注意,每一个矩形必须立刻涂满,不能只涂一部分。 写一个程序求一个使APM拿起刷子次数最少的涂色方案。注意,如果一把刷子被拿起超过一次,则每一次都必须记入总数中。

文件paint.in第一行为矩形的个数N。 下面有N行描述了N个矩形。每个矩形有5个整数描述,左上角的y坐标和x坐标,右下角的y坐标和x坐标,以及预定颜色。 颜色号为120的整数。 平板的左上角坐标总是(0, 0)。 坐标的范围是0..99 N小于16

输出至文件paint.out,文件中记录拿起刷子的最少次数。

paint.in 7 0 0 2 2 1 0 2 1 6 2 2 0 4 2 1 1 2 4 4 2 1 4 3 6 1 4 0 6 4 1 3 4 6 6 2

paint.out 3

0

 

【培训习题.动态规划】8.6paint平板涂色

2017-04-13 16:56:25

1

64

N

0

0

0

1234

【培训习题.动态规划】8.7pasture三角形牧场

和所有人一样,奶牛喜欢变化。它们正在设想新造型的牧场。奶牛建筑师Hei想建造围有漂亮白色栅栏的三角形牧场。她拥有N(3≤N≤40)块木板,每块的长度Li(1≤Li≤40)都是整数,她想用所有的木板围成一个三角形使得牧场面积最大。 请帮助Hei小姐构造这样的牧场,并计算出这个最大牧场的面积。

1行:一个整数N 2..N+1行:每行包含一个整数,即是木板长度。

仅一个整数:最大牧场面积乘以100然后舍尾的结果。 如果无法构建,输出-1

pasture.in 5 1 1 3 3 4

pasture.out 692

0

【样例解释】 692=舍尾后的(100×三角形面积),此三角形为等边三角形,边长为4

【培训习题.动态规划】8.7pasture三角形牧场

2017-04-13 16:56:25

1

64

N

0

2

0

1235

【培训习题.动态规划】8.8teams分组

你的任务是把一些人分成两组,使得: 每个人都被分到其中一组; 每个组都至少有一个人; 一组中的每个人都认识其他同组成员; 两组的成员人数近两接近。 这个问题可能有多个解决方案,你只要输出任意一个即可,或者输出这样的分组法不存在。

为了简单起见,所有的人都用一个整数标记,每个人号码不同,从1N。 输入文件的第一行包括一个整数N2≤N≤100),N就是需要分组的总人数; 接下来的N行对应了这N个人,按每个人号码的升序排列,每一行给出了一串号码Aij1≤Aij≤NAij≠i),代表了第i个人所认识的人的号码,号码之间用空格隔开,并以一个“0”结束。

如果分组方法不存在,就输出信息“No solution”(输出时无需加引号)至输出文件; 否则用两行输出分组方案; 第一行先输出第一组的人数, 然后给出第一组成员的号码,每个号码前有一个空格,同理给出第二组的信息。 每组的成员号码顺序和组别顺序并不重要。

teams.in 5 2 3 5 0 1 4 5 3 0 1 2 5 0 1 2 3 0 4 3 2 1 0

teams.out 3 1 3 5 2 2 4

0

 

【培训习题.动态规划】8.8teams分组

2017-04-13 16:56:25

1

64

N

0

0

0

1236

【培训习题.数学问题】9.1equal多项式展开

二项式展开系数大家已经十分熟悉了: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1236a.gif >

第一行,两个整数nt,中间用空格分隔。分别表示多项式幂和项数。 第二行,t个整数n1, n2, … nt,中间用空格分隔。分别表示x1, x2, …, xn的幂。(n1+n2+…+nt=n1≤n, t≤12

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1236b.gif >

equal.in 3 3 2 1 0

equal.out 3

0

【知识准备】 组合数运算; 二项式展开; 代数式的恒等变形。

【培训习题.数学问题】9.1equal多项式展开系数

2017-04-13 16:56:25

1

64

N

0

2

0

1237

【培训习题.数学问题】9.2pair两数之和

我们知道从n个非负整数中任取两个相加共有n*(n-1)/2个和,现在已知这n*(n-1)/2个和值,要求n个非负整数。

输入文件仅有一行,包含n*(n-1)/2+1个空格隔开的非负整数,其中第一个数表示n(2<n<10),其余n*(n-1)/2个数表示和值,每个数不超过100000

输出文件仅一行,按从小到大的次序依次输出一组满足要求的n个非负整数,相邻两个整数之间用一个空格隔开; 若问题无解则输出“Impossible”

pair.in 3 1269 1160 1663

pair.out 383 777 886

0

 

【培训习题.数学问题】9.2pair两数之和

2017-04-13 16:56:25

1

64

N

0

0

0

1238

【培训习题.数学问题】9.3box盒子与球

现有r个互不相同的盒子和n个互不相同的球,要将这n个球放入r个盒子中,且不允许有空盒子。问有多少种方法? 例如:有2个不同的盒子(分别编为1号和2号)和3个不同的球(分别编为123号),则有6种不同的方法: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1238.gif >

两个整数,nr,中间用空格分隔。(0≤n, r≤10

仅一行,一个整数(保证在长整型范围内)。表示n个球放入r个盒子的方法。

box.in 3 2

box.out 6

0

【知识准备】 第二类Stirling数。

【培训习题.数学问题】9.3box盒子与球

2017-04-13 16:56:25

1

64

N

0

3

0

1239

【培训习题.数学问题】9.4cycle取数游戏

有一个取数的游戏。初始时,给出一个环,环上的每条边上都有一个非负整数。这些整数中至少有一个0。然后,将一枚硬币放在环上的一个节点上。两个玩家就是以这个放硬币的节点为起点开始这个游戏,两人轮流取数,取数的规则如下: (1)选择硬币左边或者右边的一条边,并且边上的数非0; (2)将这条边上的数减至任意一个非负整数(至少要有所减小); (3)将硬币移至边的另一端。 如果轮到一个玩家走,这时硬币左右两边的边上的数值都是0,那么这个玩家就输了。 如下图,描述的是AliceBob两人的对弈过程,其中黑色节点表示硬币所在节点。结果图(d)中,轮到Bob走时,硬币两边的边上都是0,所以Alcie获胜。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1239.gif > aAlice bBob cAlice dBob 现在,你的任务就是根据给出的环、边上的数值以及起点(硬币所在位置),判断先走方是否有必胜的策略。

第一行一个整数NN≤20),表示环上的节点数。 第二行N个数,数值不超过30,依次表示N条边上的数值。硬币的起始位置在第一条边与最后一条边之间的节点上。

仅一行。若存在必胜策略,则输出“YES”,否则输出“NO”

cycle1.in 4 2 5 3 0 cycle2.in 3 0 0 0

cycle1.out YES cycle2.out NO

0

 

【培训习题.数学问题】9.4cycle取数游戏

2017-04-13 16:56:25

1

64

N

0

1

0

1240

【培训习题.数学问题】9.5defrag磁盘碎片整理

出于最高安全性考虑,司令部采用了特殊的安全操作系统,该系统采用一个特殊的文件系统。在这个文件系统中所有磁盘空间都被分成了相同尺寸的N块,用整数1N标识。每个文件占用磁盘上任意区域的一块或多块存储区,未被文件占用的存储块被认为是可是用的。如果文件存储在磁盘上自然连续的存储块中,则能被以最快的速度读出。 因为磁盘是匀速转动的,所以存取上面不同的存储块需要的时间也不同。读取磁盘开头处的存储块比读取磁盘尾处的存储块快。根据以上现象,我们事先将文件按其存取频率的大小用整数1K标识。按文件在磁盘上的最佳存储方法,1号文件将占用1, 2, …, S1的存储块,2号文件将占用S1+1, S1+2, … S1+S2的存储块,以此类推(Si是被第i个文件占用的存储块的个数)。为了将文件以最佳形式存储在磁盘上,需要执行存储块移动操作。一个存储块移动操作包括从磁盘上读取一个被占用的存储块至内存并将它写入其他空的存储块,然后宣称前一个存储块被释放,后一个存储块被占用。 本程序的目的是通过执行最少次数的存储块移动操作,将文件安最佳方式存储到磁盘上,注意同一个文件的存储块在移动之后其相对次序不可改变。

每个磁盘说明的第一行包含两个用空格隔开的整数NK(1≤K≤N≤100000), 接下来的K行每行说明一个文件,对第i个文件的说明是这样的:首先以整数Si开头,表示第i个文件的存储块数量,1<=Si<=N-K,然后跟Si个整数,每个整数之间用空格隔开,表示该文件按自然顺序在磁盘上占用的存储块的标识。 所有这些数都介于1N之间,包括1N。 一个磁盘说明中所有存储块的标识都是不同的,并且该盘至少有一个空的存储块。

对于每一个磁盘说明,只需输出一行句子“We need M move operations” M表示将文件按最佳方式存储到磁盘上所需进行的最少存储块移动操作次数。 如果文件已按最佳方式存储,仅需输出“No optimization needed.”

defrag.in 20 3 4 2 3 11 12 1 7 3 18 5 10

defrag.out We need 9move operations

0

 

【培训习题.数学问题】9.5defrag磁盘碎片整理

2017-04-13 16:56:25

1

64

N

0

0

0

1241

【培训习题.数学问题】9.6game欧几里德的游戏

欧几里德的两个后代StanOllie正在玩一种数字游戏,这个游戏是他们的祖先欧几里德发明的。给定两个正整数MN,从Stan开始,从其中较大的一个数,减去较小的数的正整数倍,当然,得到的数不能小于0。然后是Ollie,对刚才得到的数,和MN中较小的那个数,再进行同样的操作……直到一个人得到了0,他就取得了胜利。下面是他们用(257)两个数游戏的过程: Start25 7 Stan11 7 Ollie4 7 Stan4 3 Ollie1 3 Stan1 0 Stan赢得了游戏的胜利。 现在,假设他们完美地操作,谁会取得胜利呢?

第一行为测试数据的组数C。 下面有C行,每行为一组数据,包含两个正整数M, N。(M, N不超过长整型。)

对每组输入数据输出一行, 如果Stan胜利,则输出“Stan wins”; 否则输出“Ollie wins”

game.in 2 25 7 24 15

game.out Stan wins Ollie wins

0

 

【培训习题.数学问题】9.6game欧几里德的游戏

2017-04-13 16:57:11

1

64

N

0

2

0

1242

【培训习题.数学问题】9.7pepsl世界杯之旅

“……20026月之前购买的百事任何饮料的瓶盖上都会有一个百事球星的名字。只要凑齐所有百事球星的名字,就可参加百事世界杯之旅的抽奖活动,获得球星背包,随声听,更克赴日韩观看世界杯。还不赶快行动!你关上电视,心想:假设有n个不同的球星名字,每个名字出现的概率相同,平均需要买几瓶饮料才能凑齐所有的名字呢?

整数n2≤n≤33),表示不同球星名字的个数。

输出凑齐所有的名字平均需要买的饮料瓶数。如果是一个整数,则直接输出,否则应该直接按照分数格式输出,例如五又二十分之三应该输出为: 3 5-- 20 第一行是分数部分的分子, 第二行首先是整数部分,然后是由减号组成的分数线, 第三行是分母。减号的个数应等于分母的为数。分子和分母的首位都与第一个减号对齐。 分数必须是不可约的。

pepsi.in 2

pepsi.out 3

0

【提示】 平均的定义:如果在任意多次随机实验中,需要购买k1, k2, k3, …瓶饮料才能凑齐,而k1, k2, k3, …出现的频率分别是p1, p2, p3, …,那么,平均需要购买的饮料瓶数应为:k1* p1+k2*p2+k3* p3+…

【培训习题.数学问题】9.7pepsl百事世界杯之旅

2017-04-13 16:57:11

1

64

N

0

0

0

1243

【培训习题.数学问题】9.8pour倒酒

Winy是一家酒吧的老板,他的酒吧提供两种体积的啤酒,a mlb ml,分别使用容积为a mlb ml的酒杯来装载。 酒吧的生意并不好。Winy发现酒鬼们都非常穷。有时,他们会因为负担不起aml或者bml啤酒的消费,而不得不离去。因此,Winy决定出售第三种体积的啤酒(较小体积的啤酒) Winy只有两种杯子,容积分别为a mlb ml,而且啤酒杯是没有刻度的。他只能通过两种杯子和酒桶间的互相倾倒来得到新的体积的酒。 为了简化倒酒的步骤,Winy规定: (1a≥b; (2)酒桶容积无限大,酒桶中酒的体积也是无限大(但远小于桶的容积); (3)只包含三种可能的倒酒操作: 将酒桶中的酒倒入容积为b ml的酒杯中; 将容积为a ml的酒杯中的酒倒入酒桶; 将容积为b ml的酒杯中的酒倒入容积为a ml的酒杯中。 (4)每次倒酒必须把杯子倒满或把被倾倒的杯子倒空。 Winy希望通过若干次倾倒得到容积为a ml酒杯中剩下的酒的体积尽可能小,他请求你帮助他设计倾倒的方案

两个整数ab0<b≤a≤10<sup>9</sup>

第一行一个整数c,表示可以得到的酒的最小体积。 第二行两个整数PaPb(中间用一个空格分隔),分别表示从体积为a ml的酒杯中倒出酒的次数和将酒倒入体积为b ml的酒杯中的次数。 若有多种可能的PaPb满足要求,那么请输出Pa最小的一个。若在Pa最小的情况下,有多个Pb满足要求,请输出Pb最小的一个。

pour.in 5 3

pour.out 1 1 2 倾倒的方案为: 1、桶->B杯; 2B->A杯; 3、桶->B杯; 4B->A杯; 5A->; 6B->A杯;

0

 

【培训习题.数学问题】9.8pour倒酒

2017-04-13 16:57:11

1

64

N

0

1

0

1244

【培训习题.数学问题】9.9reunion班级聚会

毕业25年以后,我们的主人公开始准备同学聚会。打了无数电话后他终于搞到了所有同学的地址。他们有些人仍在本城市,但大多数人分散在其他的城市。不过,他发现一个巧合,所有地址都恰好分散在一条铁路线上。他准备出发邀请但无法决定应该在哪个地方举行宴会。最后他决定选择一个地点,使大家旅行的花费和最小。 不幸的是,我们的主人公既不擅长数学,也不擅长计算机。他请你帮忙写一个程序,根据他同学的地址,选择聚会的最佳地点。

输入文件的每一行描述了一个城市的信息。 首先是城市里同学的个数,紧跟着是这个城市到Moscow(起点站)的距离(km),最后是城市的名称。 最后一行描述的总是Moscow,它在铁路线的一端,距离为0

聚会地点城市名称和旅行费用(单程),两者之间用一空格隔开。 每km花费一个卢布。

reunion.in 7 9289 Vladivostok 5 8523 Chabarovsk 3 5184 Irkutsk 8 2213 Yalutorovsk 10 0 Moscow

reunion.out Yalutorovsk 112125

0

 

【培训习题.数学问题】9.9reunion班级聚会

2017-04-13 16:57:11

1

64

N

0

1

0

1245

【培训习题.杂题】10.1sillysort排序

有一列数,要对其进行排序(升序)。排序只能通过交换来实现。每次交换,可以选择这列数中的任意两个,交换他们的位置,并且交换的代价为这两个数的和。 排序的总代价是排序过程中所有交换代价之和。现要求计算,对于任意给出的一列数,要将其排成升序所需的最小代价。

输入包含多组数据。每组数据有两行组成。 第一行一个数n,表示这列数共有n个数组成。 第二行n个互不相同的整数(都是小于1000的正整数),表示这列数。 输入文件以n0结尾。

对于每组输入数据,输出组号和排序所需的最小代价。

sillysort.in 3 3 2 1 4 8 1 2 4 5 1 8 9 7 6 6 8 4 5 3 2 7 0

sillysort.out Case 14 Case 217 Case 341 Case 434

0

【知识准备】 置换及其循环节的基本知识。

【培训习题.杂题】10.1sillysort排序

2017-04-13 16:57:11

1

64

N

0

1

0

1246

【培训习题.杂题】10.2stick木棍加工

一堆木头棍子共有n根,每根棍子的长度和宽度都是已知的。棍子可以被一台机器一个接一个地加工。机器处理一根棍子之前需要准备时间。准备时间是这样定义的: 第一根棍子的准备时间为1分钟; 如果刚处理完长度为L,宽度为W的棍子,那么如果下一个棍子长度为Li,宽度为Wi,并且满足L>LiW>Wi,这个棍子就不需要准备时间,否则需要1分钟的准备时间; 计算处理完n根棍子所需要的最短准备时间。比如,你有5根棍子,长度和宽度分别为(4, 9)(5, 2)(2, 1)(3, 5)(1, 4),最短准备时间为2(按(4, 9)(3, 5)(1, 4)(5, 2)(2, 1)的次序进行加工)。

第一行是一个整数n(n<5000), 第2行是2n个整数,分别是L1W1L2w2LnWnLW的值均不超过10000,相邻两数之间用空格分开。

仅一行,一个整数,所需要的最短准备时间。

stick.in 5 4 9 5 2 2 1 3 5 1 4

stick.out 2

0

【知识准备】 基本动态规划原理。

【培训习题.杂题】10.2stick木棍加工

2017-04-13 16:57:11

1

64

N

0

0

0

1247

【培训习题.杂题】10.3tr三角形

给出平面上的n个等腰直角三角形。每个三角形用3个整数描述x, y, mm>0)。一个三角形的3个顶点分别是(x, y)(x+m, y)and(x, y+m)。 你的任务是计算这些三角形覆盖的总面积。

输入文件tr.in第一行是整数nn≤2000)。 接下来n行每行描述一个三角形,包括3个整数xiyimi(1≤i≤n-107≤xi≤107-107≤yi≤1070<mi≤1000)

输出文件仅包含一个实数,精确到小数点后一位,表示总面积。

tr.in 5 -5 -3 6 -1 -2 3 0 0 2 -2 2 1 -4 -1 2

tr.out 24.5 样例解释如图10-1 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1247.gif>

0

【知识准备】 离散化的基本原理和实现。

【培训习题.杂题】10.3tr三角形

2017-04-13 16:57:11

1

64

N

0

1

0

1248

【培训习题.杂题】10.4area多边形面积

给出一个简单多边形(没有缺口),它的边要么是垂直的,要么是水平的。要求计算多边形的面积。 多边形被放置在一个X-Y的卡笛尔平面上,它所有的边都平行于两条坐标轴之一。然后按逆时针方向给出各顶点的坐标值。 所有的坐标值都是整数(因此多边形的面积也为整数)

输入文件第一行给出多边形的顶点数n(n≤100)。 接下来的n行每行给出多边形一个顶点的坐标值XY(都为整数并且用空格隔开)。 顶点按逆时针方向逐个给出。 并且多边形的每一个顶点的坐标值-200≤xy≤200。 多边形最后是靠从最后一个顶点到第一个顶点画一条边来封闭的。

输出文件仅有一行,包含一个整数,表示多边形的面积。

area.in 10 0 0 4 0 4 1 3 1 3 3 2 3 2 2 1 2 1 3 0 3

area.out 9

0

 

【培训习题.杂题】10.4area多边形面积

2017-04-13 16:57:11

1

64

N

0

0

0

1249

【培训习题.杂题】10.5cable网线切割

Wonderland居民决定举行一届地区性程序设计大赛。仲裁委员会志愿负责这次赛事并且保证会组织一次有史以来最公正的比赛。为此,所有参赛者的电脑和网络中心会以星状网络连接,也就是说,对每个参赛者,组委会会用一根长度一定的网线将他的计算机与中心连接,使得他们到网络中心的距离相等。 为了买网线,组委会与当地的网络公司联系,要向他们购买一定数目的等长网线,这些网线要尽可能的长,使得组织者可以让选手们彼此远离。 于是公司指派管理网线事务的负责人解决此事。负责人清楚地知道仓库里每根网线的长度(精确到厘米:cm),他也可以将他们以厘米的精度切割——前提是他得知道切成多长。但是现在,这个长度他算不出来,于是他彻底迷茫了。 你要做的,就是帮助困惑的负责人。编一个程序求出为了得到一定数目的等长网线,每根网线最大的可能长度。

输入文件的第一行由两个整数NK组成,由一个空格间隔。N(1≤N≤10000)是仓库里光缆的数目,K(1≤K≤10000)是需要的网线数目。 接下来的N行每行只有一个实数,告诉你每根缆线的长度(单位:m)。这些网线至少长1m,最多不超过100km。 所有的长度精确到cm,且小数点后有且仅有两位。

把你求得的最大网线长度写进输出文件(单位:m)。长度要精确到cm,并且输出时小数点后要恰有两位。 如果无论如何也不可能切割出需要数目的网线(每根至少1cm),那么就输出“0.00”(不包括引号)

cable.in 4 11 8.02 7.43 4.57 5.39

cable.out 2.00

0

 

【培训习题.杂题】10.5cable网线切割

2017-04-13 16:57:11

1

64

N

0

0

0

1250

【培训习题.杂题】10.6close最接近的分数

给出一个正小数,找出分子(非负)不超过M,分母不超过N(正数)的最简分数或整数,使其最接近给出的小数。最接近是指在数轴上该分数距离给出的小数最近, 如果这个分数不惟一,输出“TOO MANY”

输入文件共有二行, 第一行包含两个用空格隔开的正整数MN(1<MN<=107),表示要求的分数其分子不超过M,分母不超过N; 第二行为小数R(R>0)R的整数部分为一个阿拉伯数字,小数部分最多有十位。

输出文件仅一行,若解唯一则输出分子/分母(整数K写成K/1), 否则输出“TOO MANY”

close.in 360 120 3.1415926536

close.out 355/113

0

 

【培训习题.杂题】10.6close最接近的分数

2017-04-13 16:57:11

1

64

N

0

0

0

1251

【培训习题.杂题】10.7cutter切孔机

司令部的助理经常需要在大纸上切割各种形状的孔。他们刚刚购买了一台新的切孔机,该机比他们以前使用的要方便自由的多。他们想编写一个程序来求出经过一系列复杂的切孔后会发生什么情况,他们特别想知道纸上形成的孔的数量。 下图列出了经过切割后形成的一些图样。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1251.gif >

输入文件第一行是一个整数N,表示切纸操作的次数,1≤N≤100。 接下来的N行中每行给出一个精确的切割操作,每次切割都给出了用空格隔开的四个整数, x1y1x2y2-1000≤x1y1x2y2≤1000x1y1是切割线开始处的坐标值,x2y2是切割线结束时的坐标值。 你可以假设所有的切割点都在纸上,不会出界。每次切割都平行于纸上的xy坐标轴。

对于每次切割操作,要求输出纸上留下的单独的孔数。 注意任何孔的最小面积不低于1平方单位。

cutter.in 4 0 1 1 1 1 1 1 0 1 0 0 0 0 0 0 1

cutter.out 1

0

 

【培训习题.杂题】10.7cutter切孔机

2017-04-13 17:03:09

1

64

N

0

0

0

1252

【培训习题.杂题】10.8dog栓狗方案

一个公园由2000000条垂直方向的道路与2000000条水平方向的道路围成栅格状,相邻两条平行道路间的距离为1,两个方向的道路均从12000000进行编号,每个栅格(面积为1平方)中都栽有一棵树。 现在公园里有N只小狗在玩耍,它们的编号为1N。每一只小狗都套着一根固定长度的链索,并且每一只狗都有一棵特别喜欢的树,小狗总是在路上散步,且链索总是拖在道路上,而不会拖到栅格中去。 现在要把所有的小狗都栓到树上,一棵树上可以拴任意多条小狗,但拴狗方案必须满足以下条件: (1)每只小狗都能散步到达它最喜欢的树下。 (2)无论编号小的小狗溜达到什么地方,编号大的小狗都能到达该地方,即任意一个编号小的小狗的活动范围必须包含在编号比它大的小狗的活动范围之内。 请您编一程序为每一只小狗找一棵栓住它的树使得上述条件均能得到满足。

输入文件的第一行包含一个整数N(1≤N≤100000),表示小狗的数量。 接下来的N行每行包含一只小狗的信息,第I+1行表示第I只小狗的信息,每行数据的格式如下: R S D 表示这只小狗最喜欢的树位于第R行第S列,D为栓这只小狗的链索的长度,D不大于1000000

输出文件包含N行, 第I行包含一对用空格隔开的整数表示用来栓第I只小狗的树的坐标。 第一坐标表示行,第二坐标表示列, 对每一组输入数据问题保证有解,但不一定唯一。

dog.in 6 21 27 1 23 27 3 19 27 5 21 33 6 23 29 6 26 30 7

dog.out 20 27 20 27 19 28 19 29 19 29 19 30

0

 

【培训习题.杂题】10.8dog栓狗方案

2017-04-13 17:03:09

1

64

N

0

1

0

1253

【培训习题.杂题】10.9erp城市街道交通费系统

城市街道交费系统最近创立了。一辆汽车左转一次需付费$1,右转一次需付费$5。只有当前进、左转、右转都无路可走的时候,调头才是允许的,调头每次付费$10。 给出一张城市地图,要求你求出从起始点到达终止点的花费最少的路径。幸运的是,所有的道路都是正北、正南、正西或正东方向的。 【样例1】 如下图,符号‘#’代表街道,符号‘.’代表障碍区,符号‘E’表示起始站且汽车面朝东,符号‘F’表示汽车终止点。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1253/p1253a.gif > 最便宜的路径花费$8:直走,然后左转3次,最后右转到终止点F。如果先直走然后右转2次,花费将是$10。 【样例2】 如图10-2,符号‘S’表示起始站且汽车面朝南。最便宜的路径花费$7:立刻左转,直走,在第一个岔路口左转,随后右转。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1253/p1253b.gif > 城市地图高度最小为4,最大为30,城市地图宽度亦最小为4最大为30。只有一个起点、一个终点,他们之间总存在可通达的路径。同时由于地图周围一圈均是障碍区,所以汽车是没有可能开除城市的。

输入文件erp.in如下: (1)第一行有2个整数,地图高度h和宽度w。 (2)其后h行每行w个字母,将是以下字母中的一个: ‘.’表示障碍区 ‘#’表示道路 ‘E’表示起始点且汽车面朝东 ‘W’ 表示起始点且汽车面朝西 ‘N’ 表示起始点且汽车面朝北 ‘S’ 表示起始点且汽车面朝南 ‘F’ 表示终点

输出文件erp.out仅包含一个整数,即为最便宜路径的费用。

erp.in 8 11

erp.out 8 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/p1253/p1253c.gif >

0

 

【培训习题.杂题】10.9erp城市街道交通费系统

2017-04-13 17:03:09

1

64

N

0

0

0

1254

【培训习题.杂题】10.10pils魔鬼之城

在一个被分割为N*M个正方形房间的矩形魔鬼之城中,一个探险者必须遵循下列规则才能跳跃行动。他必须从(1, 1)进入,从(N, M)走出;在每一房间的墙壁上都写了一个魔法数字,是113之内的自然数;探险者可以想像出8个方向中的任何一个(水平或垂直或对角线方向),随后他就可以作一次空间跳跃穿过这一方向上的连续的X个房间,其中X是他原来所在房间的魔法数字。但如果在这一方向上的房间数小于X,则他不作任何跳跃,而必须想像另一个方向。同时,探险者不能作连续两次相同方向的跳跃。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1254.gif > 例如在上图的5*4的魔鬼之城中,如果探险者现在所在的位置是(3, 3),那么通过依次空间跳跃他可以到达下列房间中的一个:(1, 1)(3, 1)(1, 3)(5, 1),或(5, 3)。另外,如果他要用两次跳跃从(5, 4)到达(3, 2),则他不能首先跳到(4, 3)(因为这样他第二次跳跃的方向将和第一次相同,而这是不允许的)。所以他必须先跳跃到(2, 1)。 请你写一个程序,对给定的地图,算出探险者至少需要跳跃多少步才能离开魔鬼之城。

一行给出NM(都不超过100); 下来有M行,每行为N个自然数,表示对应房间中的魔法数字。

输出最小步数,如果探险者无法离开魔鬼之城,请输出“NEVER”

pils.in 5 4 3 3 6 7 11 3 2 1 1 3 3 2 2 1 1 2 1 2 2 1

pils.out 4

0

 

【培训习题.杂题】10.10pils魔鬼之城

2017-04-13 17:03:09

1

64

N

0

0

0

1255

【培训习题.杂题】10.11squares可见矩形

给定平面上n个互不相交(指公共面积为零)的正方形,它们的顶点坐标均为整数。设坐标原点为O(0, 0)。对于任一正方形R,如果可以找到R的边上2个不同的点AB,使三角形OAB的内部与其他正方形无公共点,则称正方形R是从O点可见的正方形。 对于给定的n个互不相交的正方形,计算从坐标原点O可见的正方形个数。

输入文件的第一行是正方形个数n(1≤n≤1000)。 接下来n行中,每行有3个表示正方形的整数XYL。其中,XY表示正方形的左下角顶点坐标,L表示边长,1≤X, Y, L≤10000

输出文件仅有一行包含一个整数,表示从坐标原点O可见的正方形个数。

squares.in 3 2 6 4 1 4 1 2 4 1

squares.out 3

0

 

【培训习题.杂题】10.11squares可见矩形

2017-04-13 17:03:09

1

64

N

0

1

0

1256

【并查集.1VIJOS_P1034:家 族

若某个家族人员过于庞大,要判断两个是否是亲戚,确实还很不容易,现在给出某个亲戚关系图,求任意给出的两个人是否具有亲戚关系。 规定:xy是亲戚,yz是亲戚,那么xz也是亲戚。如果x,y是亲戚,那么x的亲戚都是y的亲戚,y的亲戚也都是x的亲戚。

第一行:三个整数n,m,p,(n<=5000,m<=5000,p<=5000),分别表示有n个人,m个亲戚关系,询问p对亲戚关系。 以下m行:每行两个数MiMj1<=MiMj<=N,表示AiBi具有亲戚关系。 接下来p行:每行两个数PiPj,询问PiPj是否具有亲戚关系。

P行,每行一个’Yes’’No’。 表示第i个询问的答案为具有不具有亲戚关系。

6 5 3 1 2 1 5 3 4 5 2 1 3 1 4 2 3 5 6

Yes Yes No

0

【并查集】

VIJOS_P1034:家 族

2017-04-13 17:03:09

1

64

N

53

73

0

1257

【并查集.2VIJOS_P1234:口袋的天空

背景 Background 小杉坐在教室里,透过口袋一样的窗户看口袋一样的天空。有很多云飘在那里,看起来很漂亮,小杉想摘下那样美的几朵云,做成棉花糖。 描述 Description 给你云朵的个数N,再给你M个关系,表示哪些云朵可以连在一起。 现在小杉要把所有云朵连成K个棉花糖,一个棉花糖最少要用掉一朵云,小杉想知道他怎么连,花费的代价最小。

每组测试数据的 第一行有三个数N,M,K(1<=N<=1000,1<=M<=10000,1<=K<=10) 接下来M个数每行三个数X,Y,L,表示X云和Y云可以通过L的代价连在一起。(1<=X,Y<=N,0<=L<10000) 30%的数据N<=100,M<=1000

对每组数据输出一行,仅有一个整数,表示最小的代价。 如果怎么连都连不出K个棉花糖,请输出'No Answer'

样例1 Input: 3 1 2 1 2 1 样例2 Input: 3 1 1 1 2 1

样例1 Output: 1 样例2 Output: No Answer

0

【并查集】

VIJOS_P1234:口袋的天空

2017-04-13 17:03:09

1

64

N

23

68

0

1258

【并查集.3PKU_P1182:食物链

动物王国中有三类动物A,B,C,这三类动物的食物链构成了有趣的环形。AB BCCA。 现有N个动物,以1N编号。每个动物都是A,B,C中的一种,但是我们并不知道它到底是哪一种。 有人用两种说法对这N个动物所构成的食物链关系进行描述: 第一种说法是“1 X Y”,表示XY是同类。 第二种说法是“2 X Y”,表示XY。 此人对N个动物,用上述两种说法,一句接一句地说出K句话,这K句话有的是真的,有的是假的。当一句话满足下列三条之一时,这句话就是假话,否则就是真话。 1.当前的话与前面的某些真的话冲突,就是假话; 2.当前的话中XYN大,就是假话; 3.当前的话表示XX,就是假话。 你的任务是根据给定的N1<=N<=50,000)和K句话(0<=K<=100,000),输出假话的总数。

第一行是两个整数NK,以一个空格分隔。 以下K行每行是三个正整数 DXY,两数之间用一个空格隔开,其中D表示说法的种类。 若D=1,则表示XY是同类。 若D=2,则表示XY

输出文件(eat.out) 只有一个整数,表示假话的数目。

100 7 1 101 1 2 1 2 2 2 3 2 3 3 1 1 3 2 3 1 1 5 5

输出样例 3

0

<p> 【并查集】 </p> <p> 7句话的分析<br /> 100 7 <br /> 1 101 1  假话<br /> 2 1 2  真话<br /> 2 2 3  真话<br /> 2 3 3   假话<br /> 1 1 3  假话<br /> 2 3 1  真话<br /> 1 5 5  真话<br /> <div> <br /> </div> </p>

PKU_P1182:食物链 (NOI2001)

2017-04-24 08:29:33

1

64

N

9

18

0

1259

【并查集.4NOI2002_Day1_T1:银河英雄传说

公元五八一年,地球居民迁移至金牛座α第二行星,在那里发表银河联邦创立宣言,同年改元为宇宙历元年,并开始向银河系深处拓展。 宇宙历七九九年,银河系的两大军事集团在巴米利恩星域爆发战争。泰山压顶集团派宇宙舰队司令莱因哈特率领十万余艘战舰出征,气吞山河集团点名将杨威利组织麾下三万艘战舰迎敌。 杨威利擅长排兵布阵,巧妙运用各种战术屡次以少胜多,难免恣生骄气。在这次决战中,他将巴米利恩星域战场划分成30000列,每列依次编号为1, 2, …, 30000。之后,他把自己的战舰也依次编号为1, 2, …, 30000,让第i号战舰处于第i(i = 1, 2, …, 30000),形成一字长蛇阵,诱敌深入。这是初始阵形。当进犯之敌到达时,杨威利会多次发布合并指令,将大部分战舰集中在某几列上,实施密集攻击。合并指令为M i j,含义为让第i号战舰所在的整个战舰队列,作为一个整体(头在前尾在后)接至第j号战舰所在的战舰队列的尾部。显然战舰队列是由处于同一列的一个或多个战舰组成的。合并指令的执行结果会使队列增大。 然而,老谋深算的莱因哈特早已在战略上取得了主动。在交战中,他可以通过庞大的情报网络随时监听杨威利的舰队调动指令。 在杨威利发布指令调动舰队的同时,莱因哈特为了及时了解当前杨威利的战舰分布情况,也会发出一些询问指令:C i j。该指令意思是,询问电脑,杨威利的第i号战舰与第j号战舰当前是否在同一列中,如果在同一列中,那么它们之间布置有多少战舰。 作为一个资深的高级程序设计员,你被要求编写程序分析杨威利的指令,以及回答莱因哈特的询问。 最终的决战已经展开,银河的历史又翻过了一页……

输入文件galaxy.in的第一行有一个整数T1<=T<=500,000),表示总共有T条指令。 以下有T行,每行有一条指令。指令有两种格式: 1.M i j ij是两个整数(1<=i , j<=30000),表示指令涉及的战舰编号。该指令是莱因哈特窃听到的杨威利发布的舰队调动指令,并且保证第i号战舰与第j号战舰不在同一列。 2.C i j ij是两个整数(1<=i , j<=30000),表示指令涉及的战舰编号。该指令是莱因哈特发布的询问指令。

输出文件为galaxy.out。你的程序应当依次对输入的每一条指令进行分析和处理:如果是杨威利发布的舰队调动指令,则表示舰队排列发生了变化,你的程序要注意到这一点,但是不要输出任何信息;如果是莱因哈特发布的询问指令,你的程序要输出一行,仅包含一个整数,表示在同一列上,第i号战舰与第j号战舰之间布置的战舰数目。如果第i号战舰与第j号战舰当前不在同一列上,则输出-1

【样例输入】 4 M 2 3 C 1 2 M 2 4 C 4 2

【样例输出】 -1 1

0

【并查集】

NOI2002_Day1_T1:银河英雄传说

2017-04-25 22:23:12

5

64

N

8

33

0

1260

【栈.110进制到n进制转换

输入一个十进制的正整数m,及确定进制n,把这个数转换成相应的n进制输出。 (其中2<n<=16)

一行,两个数mn m为要转换的十进制数,其中m<=32767 nm将转换成的进制,其中2<n<=16。

一行:一个数,即转换的结果。 注意转换后输出格式。

8 2

(1000)2

0

 

【栈】10进制到n进制转换

2017-04-13 17:03:09

1

64

N

4

7

0

1261

【栈.2】计算后缀表达式

所谓后缀表达式是指这样的一个表达式:式中不再引用括号,运算符号放在两个运算对象之后,所有计算按运算符号出现的顺序,严格地由左而右新进行(不用考虑运算符的优先级)。 例如:3*(52)+7对应的后缀表达式为:352-*7+@ 其中'@'为后缀表达式的结束标记。'.'为操作数的结束符号。 352-*7+@ =33*7+@ =97+@ =16

输入:后缀表达式A (以 '@'表示表达式的结束 ) 假定A合乎文法,不需判错。

输出:表达式的值。

输入文件houzhui.in共有1行 是一个后缀表达式 (以 ’@’表示表达式的结束 ) 其中输入的数字都是整数 并且小于1000 在输入的后缀表达式中可能包含 + - * / 四则运算 【输入样例】 20.6.+9.*104.-10./@

输出数据houzhui.out共一行, 是后缀表达式的运算结果。 要求输出数据共占8格。 其中小数部分为2位 【输出样例】 13.00

0

 

【栈.2】计算后缀表达式

2017-04-13 17:08:40

1

64

N

0

2

0

1262

【栈.3】火车调度问题

编号为12……nn辆列车顺序进入一个栈式结构的站台。 试给出这n辆列车开出车站的所有可能次序的总数。

输入文件huoche.in共一行:  一个整数n,表示火车的数量;(N < =10)

输出文件huoche.out 可能出现的情况总数。

3

5

0

 

 

2017-04-13 17:08:40

1

64

N

1

1

0

1263

【栈.4】中缀变后缀表达式

《将中缀表达式转换成等价的后缀表达式》 中缀表达式的书写格式与通常的表达式大致相同,只不过增加了两个符号: '@'-->表达式的结束标志; '.'-->操作数的结束标志;

输入:中缀表达式e(注:假定中缀表达式已完全合乎文法,不需要判错)。

输出:计算顺序和结果完全相同的后缀表达式a

((3.*(5.-2.))+7.)@

3.5.2.-*7.+@

0

 

【栈.4】中缀变后缀表达式

2017-04-13 17:08:40

1

64

N

1

1

0

1264

【栈.5】四色问题

设有下列形状的图形:n个区域(1<=n<=100,各区域的相邻关系用0(不相邻)、1(相邻)表示。 例如,有对应图形5.1.2如下: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1264b.gif> 该图形对应表5.1.1,所构成的邻接矩阵如下: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1264a.gif> 将上面图形5.1.2的每一部分涂上红(1)、黄(2)、蓝(3)、绿(4)四种颜色之一,要求相邻部分的颜色不同。

输入文件格式为: 第一行,为一个整数n1<=n<=100,表示有n块区域。 从第2行至n+1行,共n行,每行由n个元素,构成n*n01矩阵。

输出文件格式: 共n行,第i行表示第i块区码所用的填充颜色码。格式如下: 1->区域1的颜色码 2->区域2的颜色码 …… n->区域n的颜色码

8 0 1 0 0 0 0 1 1 1 0 1 0 0 1 1 0 0 1 0 1 0 1 0 0 0 0 1 0 1 1 0 0 0 0 0 1 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 0 1 0 1 1 0 0 0 0 0 1 0

1->1 2->2 3->1 4->2 5->1 6->3 7->4 8->2

0

 

【栈.5】四色问题

2017-04-13 17:08:40

1

64

N

1

2

0

1265

USACO_2.2-3:Runaround Numbers循环数

循环数是那些不包括0这个数字的没有重复数字的整数 (比如说, 81362) 并且同时具有一个有趣的性质, 就像这个例子: 如果你从最左边的数字开始 ( 在这个例子中是8) 数最左边这个数字到右边(回到最左边如果数到了最右边),你会停止在另一个新的数字(如果没有停在一个不同的数字上,这个数就不是循环数).就像: 8 1 3 6 2 从最左边接下去数8个数字: 1 3 6 2 8 1 3 6 所以下一个数字是6. 重复这样做 (这次从“6”开始数6个数字) 并且你会停止在一个新的数字上: 2 8 1 3 6 2, 也就是2. 再这样做 (这次数两个): 8 1;再一次 (这次一个): 3; 又一次: 6 2 8 这是你回到了起点, 在从每一个数字开始数1次之后. 如果你在从每一个数字开始数一次以后没有回到起点, 你的数字同样也不是一个循环数。(本样例起点为8) 给你一个数字 M (19位之间), 找出第一个比 M大的循环数, 并且一定能用一个无符号长整形数装下。

仅仅一行,包含M。(M为无符号长整形数)

仅仅一行,包括第一个比M大的循环数。

81361

81362

0

 

USACO_2.2-3:Runaround Numbers循环数

2017-04-13 17:08:40

1

64

N

2

2

0

1266

【基础题.文件】高一(3)班会考登分

每一年的信息技术会考快要来临了,路桥中学的许多学生开始为会考做一些复习准备,信息技术组老师都比较喜欢使用《2007会考导引练习系统》来筑固复习《信息技术基础》部分内容,如果你对上学期内容忘记较多,可得好好练习哦!…… 作广告: 该练习系统的确不错,同学们可以用来自我评分,还可以上交成绩。相同的一个同学可以提交多次! 在学生做作业时,电脑老师要求同学写自己的真实姓名,并在名字前面加上学号:如用户名为:03张三。 假设,电脑老师教师机上接收到的学生上交的成绩是一个文本文件,如下所示: 10.10.21.31#2c1#31.陈俊伶#57#试卷一 10.10.21.61#2f1#18碰志杰#58#试卷一 10.10.21.41#2d1#01蔡仁伟#58#试卷一 10.10.21.33#2c3#15南星宇#58#试卷一 10.10.21.73#2G3#04陈恩伟#58#试卷一 10.10.21.55#2e5#25,应志华#58#试卷一 10.10.21.82#2h2#34.池雨#55#试卷一 …… …… …… …… 若一个同学做题速度很快,他甚至可以提交很多次! 为了了解学生复习情况,电脑老师想登记上面每个学生成绩。(满分为:58分) 电脑老师的眼睛一般都不太好,比较容易看花! 请你帮助电脑老师,将该成绩表排好顺序(按学号排好就可以了) 另外顺掉去掉每个同学学号前面的一大串无用信息。

输入文件, 文件中可能有N行,N是没法确定的,可以比int64还要多。 每行表示一次学生成绩上交成绩信息,其格式如下: 10.10.21.31#2c1#31.陈俊伶#57#试卷一

输出文件, 文件中可能有N行。 每行表示一次学生成绩信息,其格式如下: 31.陈俊伶#57#试卷一

10.10.21.31#2c1#31.陈俊伶#57#试卷一 10.10.21.61#2f1#18碰志杰#58#试卷一 10.10.21.41#2d1#01蔡仁伟#58#试卷一 10.10.21.33#2c3#15南星宇#58#试卷一 10.10.21.73#2G3#04陈恩伟#58#试卷一 10.10.21.55#2e5#25,应志华#58#试卷一 10.10.21.82#2h2#34.池雨#55#试卷一

01蔡仁伟#58#试卷一 04陈恩伟#58#试卷一 15南星宇#58#试卷一 18碰志杰#58#试卷一 25,应志华#58#试卷一 31.陈俊伶#57#试卷一 34.池雨#55#试卷一

0

 

【基础题.文件】会考登分

2017-04-13 17:08:40

1

64

N

1

1

0

1267

matrix67教程:位运算

去年年底写的关于位运算的日志是这个Blog里少数大受欢迎的文章之一,很多人都希望我能不断完善那篇文章。后来我看到了不少其它的资料,学习到了更多关于位运算的知识,有了重新整理位运算技巧的想法。从今天起我就开始写这一系列位运算讲解文章,与其说是原来那篇文章的follow-up,不如说是一个remake。当然首先我还是从最基础的东西说起。 什么是位运算? 程序中的所有数在计算机内存中都是以二进制的形式储存的。位运算说穿了,就是直接对整数在内存中的二进制位进行操作。比如,and运算本来是一个逻辑运算符,但整数与整数之间也可以进行and运算。举个例子,6的二进制是11011的二进制是1011,那么6 and 11的结果就是2,它是二进制对应位进行逻辑运算的结果(0表示False1表示True,空位都当0处理): 110 AND 1011 ---------- 0010 --> 2 由于位运算直接对内存数据进行操作,不需要转成十进制,因此处理速度非常快。当然有人会说,这个快了有什么用,计算6 and 11没有什么实际意义啊。这一系列的文章就将告诉你,位运算到底可以干什么,有些什么经典应用,以及如何用位运算优化你的程序。 PascalC中的位运算符号 下面的ab都是整数类型,则: C语言 | Pascal语言 -------+------------- a & b | a and b a | b | a or b a ^ b | a xor b ~a | not a a << b | a shl b a >> b | a shr b 注意C中的逻辑运算和位运算符号是不同的。520|1314=1834,但520||1314=1,因为逻辑运算时5201314都相当于True。同样的,!a~a也是有区别的。 各种位运算的使用 === 1. and运算 === and运算通常用于二进制取位操作,例如一个数 and 1的结果就是取二进制的最末位。这可以用来判断一个整数的奇偶,二进制的最末位为0表示该数为偶数,最末位为1表示该数为奇数. === 2. or运算 === or运算通常用于二进制特定位上的无条件赋值,例如一个数or 1的结果就是把二进制最末位强行变成1。如果需要把二进制最末位变成0,对这个数or 1之后再减一就可以了,其实际意义就是把这个数强行变成最接近的偶数。 === 3. xor运算 === xor运算通常用于对二进制的特定一位进行取反操作,因为异或可以这样定义:01异或0都不变,异或1则取反。 xor运算的逆运算是它本身,也就是说两次异或同一个数最后结果不变,即(a xor b) xor b = axor运算可以用于简单的加密,比如我想对我MM1314520,但怕别人知道,于是双方约定拿我的生日19880516作为密钥。1314520 xor 19880516 = 20665500,我就把20665500告诉MMMM再次计算20665500 xor 19880516的值,得到1314520,于是她就明白了我的企图。 下面我们看另外一个东西。定义两个符号#@(我怎么找不到那个圈里有个叉的字符),这两个符号互为逆运算,也就是说(x # y) @ y = x。现在依次执行下面三条命令,结果是什么? x <- x # y y <- x @ y x <- x @ y 执行了第一句后x变成了x # y。那么第二句实质就是y <- x # y @ y,由于#@互为逆运算,那么此时的y变成了原来的x。第三句中x实际上被赋值为(x # y) @ x,如果#运算具有交换律,那么赋值后x就变成最初的y了。这三句话的结果是,xy的位置互换了。 加法和减法互为逆运算,并且加法满足交换律。把#换成+,把@换成-,我们可以写出一个不需要临时变量的swap过程(Pascal) procedure swap(var a,b:longint); begin a:=a + b; b:=a - b; a:=a - b; end; 好了,刚才不是说xor的逆运算是它本身吗?于是我们就有了一个看起来非常诡异的swap过程: procedure swap(var a,b:longint); begin a:=a xor b; b:=a xor b; a:=a xor b; end; === 4. not运算 === not运算的定义是把内存中的01全部取反。使用not运算时要格外小心,你需要注意整数类型有没有符号。如果not的对象是无符号整数(不能表示负数),那么得到的值就是它与该类型上界的差,因为无符号类型的数是用$0000$FFFF依次表示的。下面的两个程序(仅语言不同)均返回65435 var a:word; begin a:=100; a:=not a; writeln(a); end. #include <stdio.h> int main() { unsigned short a=100; a = ~a; printf( "%d\n", a ); return 0; } 如果not的对象是有符号的整数,情况就不一样了,稍后我们会在整数类型的储存小节中提到。 === 5. shl运算 === a shl b就表示把a转为二进制后左移b位(在后面添b0)。例如100的二进制为1100100,而110010000转成十进制是400,那么100 shl 2 = 400。可以看出,a shl b的值实际上就是a乘以2b次方,因为在二进制数后添一个0就相当于该数乘以2。 通常认为a shl 1a * 2更快,因为前者是更底层一些的操作。因此程序中乘以2的操作请尽量用左移一位来代替。 定义一些常量可能会用到shl运算。你可以方便地用1 shl 16 - 1来表示65535。很多算法和数据结构要求数据规模必须是2的幂,此时可以用shl来定义Max_N等常量。 === 6. shr运算 === shl相似,a shr b表示二进制右移b位(去掉末b位),相当于a除以2b次方(取整)。我们也经常用shr 1来代替div 2,比如二分查找、堆的插入操作等等。想办法用shr代替除法运算可以使程序效率大大提高。最大公约数的二进制算法用除以2操作来代替慢得出奇的mod运算,效率可以提高60%。 位运算的简单应用 有时我们的程序需要一个规模不大的Hash表来记录状态。比如,做数独时我们需要27Hash表来统计每一行、每一列和每一个小九宫格里已经有哪些数了。此时,我们可以用27个小于2^9的整数进行记录。例如,一个只填了25的小九宫格就用数字18表示(二进制为000010010),而某一行的状态为511则表示这一行已经填满。需要改变状态时我们不需要把这个数转成二进制修改后再转回去,而是直接进行位操作。在搜索时,把状态表示成整数可以更好地进行判重等操作。这道题是在搜索中使用位运算加速的经典例子。以后我们会看到更多的例子。 下面列举了一些常见的二进制位的变换操作。 功能 | 示例 | 位运算 ----------------------+---------------------------+-------------------- 去掉最后一位 | (101101->10110) | x shr 1 在最后加一个0 | (101101->1011010) | x shl 1 在最后加一个1 | (101101->1011011) | x shl 1+1 把最后一位变成1 | (101100->101101) | x or 1 把最后一位变成0 | (101101->101100) | x or 1-1 最后一位取反 | (101101->101100) | x xor 1 把右数第k位变成1 | (101001->101101,k=3) | x or (1 shl (k-1)) 把右数第k位变成0 | (101101->101001,k=3) | x and not (1 shl (k-1)) 右数第k位取反 | (101001->101101,k=3) | x xor (1 shl (k-1)) 取末三位 | (1101101->101) | x and 7 取末k | (1101101->1101,k=5) | x and (1 shl k-1) 取右数第k | (1101101->1,k=4) | x shr (k-1) and 1 把末k位变成1 | (101001->101111,k=4) | x or (1 shl k-1) k位取反 | (101001->100110,k=4) | x xor (1 shl k-1) 把右边连续的1变成0 | (100101111->100100000) | x and (x+1) 把右起第一个0变成1 | (100101111->100111111) | x or (x+1) 把右边连续的0变成1 | (11011000->11011111) | x or (x-1) 取右边连续的1 | (100101111->1111) | (x xor (x+1)) shr 1 去掉右起第一个1的左边 | (100101000->1000) | x and (x xor (x-1)) 最后这一个在树状数组中会用到。 PascalC中的16进制表示 Pascal中需要在16进制数前加$符号表示,C中需要在前面加0x来表示。这个以后我们会经常用到。 整数类型的储存 我们前面所说的位运算都没有涉及负数,都假设这些运算是在unsigned/word类型(只能表示正数的整型)上进行操作。但计算机如何处理有正负符号的整数类型呢?下面两个程序都是考察16位整数的储存方式(只是语言不同)。 var a,b:integer; begin a:=$0000; b:=$0001; write(a,' ',b,' '); a:=$FFFE; b:=$FFFF; write(a,' ',b,' '); a:=$7FFF; b:=$8000; writeln(a,' ',b); end. #include <stdio.h> int main() { short int a, b; a = 0×0000; b = 0×0001; printf( "%d %d ", a, b ); a = 0xFFFE; b = 0xFFFF; printf( "%d %d ", a, b ); a = 0×7FFF; b = 0×8000; printf( "%d %d\n", a, b ); return 0; } 两个程序的输出均为0 1 -2 -1 32767 -32768。其中前两个数是内存值最小的时候,中间两个数则是内存值最大的时候,最后输出的两个数是正数与负数的分界处。由此你可以清楚地看到计算机是如何储存一个整数的:计算机用$0000$7FFF依次表示032767的数,剩下的$8000$FFFF依次表示-32768-1的数。32位有符号整数的储存方式也是类似的。稍加注意你会发现,二进制的第一位是用来表示正负号的,0表示正,1表示负。这里有一个问题:0本来既不是正数,也不是负数,但它占用了$0000的位置,因此有符号的整数类型范围中正数个数比负数少一个。对一个有符号的数进行not运算后,最高位的变化将导致正负颠倒,并且数的绝对值会差1。也就是说,not a实际上等于-a-1。这种整数储存方式叫做补码。 最后还有两句话 Matrix67原创 转贴请注明出处

 

 

 

 

0

 

 

2017-04-13 17:08:40

1

64

N

3

3

0

1268

给大家设计一些能打开思路的练习题

去掉最后一位(101101->10110) x shr 1 在最后加一个0(101101->1011010) x shl 1 在最后加一个1(101101->1011011) x shl 1+1 把最后一位变成1(101100->101101) x or 1 把最后一位变成0(101101->101100) x or 1-1 最后一位取反(101101->101100) x xor 1 右数第k位取反(101101->101001,k=3) x xor (1 shl (k-1)) 取末三位(1101101->101) x and 7 取末k(1101101->1101,k=5) x and (1 shl k-1) 把末k位变成1(101001->101111,k=4) x or (1 shl k-1) k位取反(101001->100110,k=4) x xor (1 shl k-1) 把右边连续的1变成0(100101111->100100000) x and (x+1) 把右起第一个0变成1(100101111->100111111) x or (x+1) 把右边连续的0变成1(11011000->11011111) x or (x-1) 取右边连续的1(100101111->1111) x xor (x+1) shr 1 去掉右起第一个1的左边(100101000->1000,树状数组) x and (x xor (x-1))

 

 

 

 

0

 

 

2017-04-13 17:08:40

1

64

N

2

2

0

1269

USACO_2.2-4:Party Lamps派对灯(IOI98)

IOI98的节日宴会上,我们有N(10<=N<=100)盏彩色灯,他们分别从1N被标上号码。这些灯都连接到四个按钮: 按钮1:当按下此按钮,将改变所有的灯:本来亮着的灯就熄灭,本来是关着的灯被点亮。 按钮2:当按下此按钮,将改变所有奇数号的灯。 按钮3:当按下此按钮,将改变所有偶数号的灯。 按钮4:当按下此按钮,将改变所有序号是3*K+1(K>=0)的灯。例如:1,4,7... 一个计数器C记录按钮被按下的次数。当宴会开始,所有的灯都亮着,此时计数器C0。 你将得到计数器C(0<=C<=10000)上的数值和经过若干操作后所有灯的状态。写一个程序去找出所有灯最后可能的与所给出信息相符的状态,并且没有重复。

(file lamps.in) 不会有灯会在输入中出现两次。 第一行: N。 第二行: C最后显示的数值。 第三行: 最后亮着的灯,用一个空格分开,以-1为结束。 第四行: 最后关着的灯,用一个空格分开,以-1为结束。

(file lamps.out) 每一行是所有灯可能的最后状态(没有重复)。每一行有N个字符,第1个字符表示1号灯,最后一个字符表示N号灯。0表示关闭,1表示亮着。这些行必须从小到大排列(看作是二进制数)。 如果没有可能的状态,则输出一行'IMPOSSIBLE'

10 1 -1 7 -1 在这个样例中,有10盏灯,只有1个按钮被按下。最后7号灯是关着的。

0000000000 0101010101 0110110110 在这个样例中,有三种可能的状态: 所有灯都关着 1,4,7,10号灯关着,2,3,5,6,8,9亮着。 1,3,5,7,9号灯关着,2, 4, 6, 8, 10亮着。

0

 

USACO_2.2-4:Party Lamps派对灯(IOI98)

2017-04-13 17:08:40

1

64

N

0

3

0

1270

USACO_2.3-1:prefix最长前缀

在生物学中,一些生物的结构是用包含其要素的大写字母序列来表示的。生物学家对于把长的序列分解成较短的(称之为元素的)序列很感兴趣。 如果一个集合 P 中的元素可以通过串联(允许重复;串联,相当于 Pascal 中的 “+” 运算符)组成一个序列 S ,那么我们认为序列 S 可以分解为 P 中的元素。并不是所有的元素都必须出现。举个例子,序列 ABABACABAAB 可以分解为下面集合中的元素: {A, AB, BA, CA, BBC} 序列 S 的前面 K 个字符称作 S 中长度为 K 的前缀。设计一个程序,输入一个元素集合以及一个大写字母序列,计算这个序列最长的前缀的长度。

输入数据的开头包括 1..200 个元素(长度为 1..10 )组成的集合,用连续的以空格分开的字符串表示。字母全部是大写,数据可能不止一行。 备注:其中每一个集合元素不会出现在两行。 元素集合结束的标志是一个只包含一个 “.” 的行。 集合中的元素没有重复。 接着是大写字母序列 S ,长度为 1..200,000 ,用一行或者多行的字符串来表示,每行不超过 76 个字符。换行符并不是序列 S 的一部分。

只有一行,输出一个整数,表示 S 能够分解成 P 中元素的最长前缀的长度。

A AB BA CA BBC . ABABACABAABC

11

0

 

USACO_2.3-1:prefix最长前缀

2017-04-13 17:08:40

1

64

N

2

2

0

1271

【访.谈录】专注与兴趣是成功的阶梯(杨弋)

专注与兴趣是成功的阶梯(访杨弋) 作者:韩晓洁 时间: 2007.10.27 文档类型/出处:NOI专刊 2007年全国信息学奥林匹克竞赛的冠军又一次光临了杨弋,这个来自安徽师大附中的男孩在该领域独占鳌头。别人都评价他聪明,而他自己却说我没什么特长。跟他的谈话在晚风中落下浅色的痕迹,他思想的小宇宙并不亚于其在计算机方面显露的才华。 杨弋是个活泼的大男孩。记者好不容易才在球场边逮到打篮球的他。他有些羞涩,几经劝说,才接受了采访。杨弋在跟人对话时会注视着你的眼睛,但是说完一句话又会害羞地低下头,脸上一副思考的表情。 坐在球场边的凳子上,杨弋从他第一次接触电脑开始谈起。那是他上小学的时候,由于当时的电脑配置都很低,所以除了打字,几乎就不能干别的。后来,电脑慢慢升级了,杨弋也开始玩游戏,学编程。那时候,程序对杨弋来说就像是游戏,他一下子爱上了这种游戏。 别人眼中的超人小学六年级时,他与初中的学生一起参加全国信息学分区联赛,获得了一等奖;2002年,上初中的杨弋第一次参加了NOIP,取得了全省一等奖的好成绩。2004年,他入选安徽省队并在当年的全国信息学奥赛中获得第16名,入选国家集训队;在2005年的IOI国家队选拔赛中,他获得第五名,因国家队仅有4个名额,杨弋很遗憾地落选了。2006年,杨弋圆了国家队之梦,以NOI第一名和APIO第一名的成绩入选国家队。今年,他又以617分的成绩再次高居榜首。NOI结束之后,他将代表中国参加IOI比赛。 在本届NOI最佳女选手获得者陈瑜希的眼里,杨弋是个超人,他在比赛中往往比第二名多出很多,他的地位几乎是无人能够撼动的。而杨弋却有着自己的烦恼,他郑重地说:我觉得要把一个人当人看,我们所认为的完人是不存在的。由于安徽师大附中只有杨弋一个人参加了信息学奥赛,他坦言自己和同学的生活节奏是不同的,参加完比赛回到学校,同学会拉着他说:下午要考试了。没有人关注他在干些什么。他心里淡淡的失落是写在脸上的。 我安慰他说:有得必有失!杨弋立刻兴奋地说:我去年在冬令营面试的时候就是因为把这句话说完,从而超时而扣分的。”2006NOI冬令营中,杨弋虽然论文分数不高,但由于基础扎实,仍然稳居第一。 对杨弋来说,他的未来注定是与信息技术联系在一起的。他在2006年已经被保送清华,而之所以又参加2007年的NOI,这个男孩心里还有另一个梦——多一次参与IOI的机会。如果今年的IOI失败了,他还可以卷土重来。 重视思维训练的男生 杨弋说自己每周花在练习题上的时间大概有20~30小时,有时候甚至是40小时。他最初接触的是LOGO语言,后来迷上了BASICPASCALC语言,从简单复制代码、检查程序输出进程,到后来热爱编程,花费了大量时间在学习语言、编程上。 由于很小就曾在IOI选拔赛中取得全国第五名的好成绩,这让他觉得,自己可以顺着这条路继续走。那么高的起点,谁又会放弃呢?在初中刚学习信息技术时,他也走过弯路。最初是不停地做新题,可是到考试时发现,连基本的题目都做不对。于是,他转变思路,加大基本题型的练习量,成绩一下子提了上去。他说自己并不花费太多时间在特别难的题目上,因为这会使他产生一种挫败感。但是为了提高的各种编程能力,杨弋会做一些有助于自己提高的题目。 杨弋觉得相比较于老师的引导,自学更为重要。他喜欢和同学交流,产生的火花能够帮助他继续思考,形成自己的思路。杨弋也喜欢上论坛跟别人讨论,但他又觉得现在论坛过多,很多问题都是浅尝辄止,不像以前论坛少时大家讨论得那么充分了。杨弋曾经在PKU的论坛上力挫群雄,获得月赛的冠军。另外,还在SGUSPOJ等论坛征战。在TOPCODER中,杨弋截至20076月的得分是2900。这使杨弋在该领域内人气很旺。 问到杨弋最擅长的题目是哪种类型的,他立刻纠正了我的说法:只有在你去做的过程中,你才知道自己是不是擅长这道题目的类型,不可能你没有做题先去把它划分类型。杨弋很重视思维的过程。 他也给刚刚参加NOI的同学提了建议:不要慌着做新题,看到别人又学会了一些新知识、新思路,自己肯定会有一点压力。不过不要着急。考卷还是基本类型和题目,关键是平时要训练自己的思维方式。杨弋觉得参加考试是一种很好的锻炼。因为平时做练习题和真正的考试是不一样的。但是,他不赞成大家把所有时间都花在练习和训练上,因为做练习题是一个枯燥的过程,过于疲劳可能会使人不想再参加比赛,丧失了乐趣的比赛就会失去动力。 杨弋的文化课成绩也是在班里名列前茅的,虽然他为自己找了一个致命的缺点:不喜欢给卷子纠错。他喜欢思维的跳跃,喜欢接受新的知识。他一直用自己的步骤和方法来安排学习,而且似乎效果还不错。 充满辩证的未来 问到杨弋的爱好,他腼腆地说:我没有什么特别坚持的爱好,就是没事去踢球或进行一些其他的球类运动。停了一下,思索片刻后很认真地说,其实人一辈子能干好几件事已经很不容易了。杨弋喜欢打游戏,参加NOI时,会跟别的选手对战“CS”。杨弋在家也是个可爱的孩子,妈妈说:以后当大老板吧!杨弋会笑着说:那怎么可能?在团体对抗赛中,杨弋是安徽队的指导,他不停地跑前跑后,跟选手们交流,时而专注地看着大屏幕。这个时候的他,更像是个驰骋在计算机世界的孩子,享受着自己的付出和汗水带来的成功与乐趣。 明年的NOI中,他将具有出比赛题的资格。用他的话说:可以折磨别人了。他说,自己没有座右铭,也没有偶像。他还没有发现自己觉得希望成为的那种人。记者问他是否崇拜自己,他却连连摇头。他说:现在无法去设想未来,只有走到了那个阶段,才会有所取舍。简单的设想可能是无法实现的。这句话充满了辩证法的味道。

 

 

 

 

0

 

 

2017-04-13 17:10:37

1

64

N

2

2

0

1272

【访.谈录】良好心态与执著信念(陈启峰)

凭良好的心态和执著的信念走进国家队(访陈启峰) 作者:米军阳 时间: 2007.10.11 文档类型/出处: IOI 2006国家队选拔赛后,记者听说有一位选手水平挺高,但最后以第五名的成绩落选国家队,非常遗憾和失望,但他很快就调整心态,投入到新的学习、训练中,终于在IOI 2007国家队选拔赛中,以总分84.83的高分名列全国第二名,顺利进入面试阶段。他就是广州中山纪念中学的陈启峰同学。在面试时,他非常出色地完成了面试过程,最终入选中国国家队,获得了为国争光的机会!下面是记者对陈启峰的采访。 记者:启峰,你好!恭喜你入选国家队,争取到了为国争光的机会!请你给大家介绍一下你是怎么接触上信息学奥赛的。 启峰:你好!谢谢!我是初一下学期末的时候才开始接触这个的。当时的情况是这样的:初一下学期快结束的时候,学校发给每一个学生一个志愿表,然后去参加选拔,选40个学生左右,结果我被选上了。之后学校搞了20天的培训,再从中筛选十多个学生,我又被选上了。当时我只知道这是业余学习计算机的兴趣班。   记者:在这之前你接触过电脑吗?知道什么是编程吗?   启峰:我小学时根本没有电脑课,之前我对电脑的印象就是可以用它来玩游戏。   记者:你们当时考的什么呀?是上机还是笔试?   启峰:哦,就是笔试,现在回想起来就是考一些与算法有关的数学题。   记者:那你会吗,你又没接触过?怎么被选上的?   启峰:会!算法这种东西在生活实践中就可以被掌握。   记者:不错,看来你就是学信息学的材料啊!呵呵!那你是如何迷上信息学,又是如何参加竞赛的呢?能给大家介绍吗?   启峰:一开始,我是为了有多点时间来使用计算机,就参加了信息学。接触之后,我发现信息学不单是我的兴趣,慢慢地,变成了爱好。我非常喜欢学信息学,并且由于我在训练中表现很突出,老师就重点培养我,把电脑室的钥匙都交给了我,使我有了更多可以自由利用的上机时间。   记者:你都做些什么?有没有趁机上网聊天、玩游戏啊?   启峰:说真的,我上网都是为了学习信息学,因为这已经是我最大的爱好。我那时候就是狂做历年来联赛的题目。   记者:后来怎么样?取得了什么样的成绩呢?   启峰:在我被选拔上这个信息学奥赛班后两三个月参加NOIP普及组,就取得了初中组一等奖,省第13名的好成绩。这对我来说也是一种鼓励。我觉得学习这个对自己的发展有好处。从那以后,我就开始要别人的程序来看,开始慢慢接触一些难的程序。但当时由于年龄小,还是不知道该如何下手。后来在老师的指导下,开始系统地看很多和算法、信息学竞赛相关的书籍,慢慢地有了很大的提高。   记者:能给大家介绍一下你都看了些什么书籍吗?   启峰:很广泛,几十本基本的算法和数据结构的书,特别推荐《算法艺术》。同时我也看国家集训队的论文和作业(www.NOI.cn上可以下载到一些资料)以及到论坛去参与问题讨论,比如说ZJUForum。   记者:你都是利用什么时间参加信息学奥赛的培训和辅导?你有耽误过其他课程的学习吗?   启峰:我所有这些有关竞赛的学习,都是利用晚自习、中午这些课外时间搞的。   记者:你参加信息学竞赛的收获有哪些?   启峰:我觉得有两个方面的收获:一是在解决问题方面,通过这三四年的有关信息学奥赛的培训、学习,我觉得自己处理问题的能力变强了;二是我的心态也受到了锻炼,心理承受能力更强,并且自己更加乐观,更加积极向上了。收获比荣誉更重要。   记者:你上高中后有升学的压力吗?我听说有些学生就是想通过竞赛来取得保送资格,你是怎么考虑的?   启峰:我上高中后,没有什么升学的压力,我的成绩比较好,我相信凭实力,自己可以上一所很好的大学。我参加信息学竞赛的时候,也不知道可以取得保送资格,还是我在NOI 2006的冬令营培训时,才知道自己可以被保送到清华。我并没有带着功利心去学习信息学。   记者:听说很多参加竞赛的学生偏科都很厉害,你也这样吗?   启峰:我没有,我其他科的成绩都不错,我还曾经被选拔为数学、物理学奥赛什么的,但我不想耽误自己的信息学竞赛,就没参与,一心只搞信息学奥赛,我相信自己可以取得好的成绩。除此之外,我的政治成绩也是非常好的。   记者:你能对喜欢信息学,并希望获奖的学生说些什么?   启峰:要善于反思、总结。以前我在ZJU上做过近千个题目。开始的时候量比较大,到后来越做越精、越难。但我不会盲目做题,会注意把学习新知识与做题相结合。   记者:你成绩这么好,能不能给其他选手介绍一下自己独特的学习方法或者心得啊? 启峰:我觉得有以下几个方面吧,只能说是体会。第一,要从心理上消除对难题的恐惧,遇到难题要敢于思考,逃避只会使你永远都不会掌握这个难题的解法。第二,看书和做题相结合。有一阵子,我只顾着一味地在网上的Online Judge做题,结果提高得很慢,因为不看书就掌握不了原本不会做的题,即使再做上一万道题目,不会的题终究还是不会。从那时起我就强迫自己看书和做题相结合。而只看书不做题也是不可取的,这样做只会导致在考场上即使你想到题目的算法,也写不出正确的程序。第三,要善于与别人交流自己的看法和想法。我每次看到不会做的题目,都会先自己独立思考,实在想不出来了就请教别人,一般都能获得满意的答案。当然,我也要经常为别人解答问题。 记者:你除了积极备战IOI 2007外,还有其他的打算没?   启峰:我想多学习一些知识,多参加一些学校以及社会上的活动,加强自己实践方面的锻炼。   记者:谢谢启峰!相信你一定可以为国争光,取得优异的成绩!   启峰:谢谢! 姓名:陈启峰 学校:广东中山纪念中学 所获奖项:NOI 20052006金牌 星座:巨蟹座 爱好:电影,哲学 人生梦想:Secret 最喜欢的颜色:绿色 最喜爱的明星:马克思 最中意的食物:番茄炒蛋 最喜欢的歌曲:《死了都要爱》 最高兴的事:我进步了 最喜欢的电视剧:A litre of tears 最中意的电影:Brave Heart 最爱做的事:睡觉 最喜欢的音乐:Pop,Country,Rock 最喜爱的运动:乒乓球 最喜欢的刊物:Chinadaily 最难忘的事情:2007.4.9被邀请回母校演讲 最得意的事情:哲学学得好 最郁闷的事情:每次比赛都生病 座右铭 :没有永远解决不了的矛盾,只有暂时解决不了的矛盾 我的空间: http://344368722qzone.qq.com/ http://www.myspace.com/124931155

 

 

 

 

0

 

 

2017-04-13 17:10:37

1

64

N

2

2

0

1273

【访.谈录】少年心事当拿云(杨沐)

少年心事当拿云(访杨沐) 作者:韩晓洁 时间: 2007.10.27 文档类型/出处:NOI专刊 从NOIP第一名到NOI第七名,再到IOI金牌得主,这一路杨沐走得很顺利。对于信息学奥赛的选手来说,这样的结果非常完美。      一、小荷初露尖尖角   1998年,杨沐有了自己的第一台电脑,开始时,我爱用电脑玩游戏,但是慢慢地明白自己该做点事了1999年,正在上小学三年级的杨沐参加了学校举办的LOGO语言比赛,在之后的四年小学比赛中,他连续拿了四年全市一等奖。小学六年级的时候,他在魏丽真老师的鼓励下参加了福州三中的计算机兴趣小组,逐渐在信息学方面有了自己的成绩。   从小霸王学习机到编程,他觉得一组数据就能完成一个电脑游戏,实在太酷了。从此,他的生活跟计算机结下了不解之缘。   从此杨沐的生活离不开计算机了,之后几乎每个周末,他都泡在学校的机房里。高中的同学对于杨沐的印象就是他似乎整天在机房里做练习。他的妈妈则告诉记者,只要有一台计算机做伴,即使给杨沐一堆的杂草,他也能安然入睡。      二、何妨吟啸且徐行   初一的时候,第一次参加NOIP的杨沐获得了二等奖。杨沐说:当时对这个成绩还是挺满意的,因为只学了半年嘛。初二的时候,他一举夺得了当年NOIP的第一名。不过,初三,他未能蝉联NOIP的冠军。他自己总结说:初二的时候,实力不是很强,能拿冠军纯粹是运气好。初三拿不到冠军感觉很正常。  高一,他以NOI夏令营营员的身份参加了NOI,获得了铜牌。那个时候,他感觉自己跟那些大牛们还是差很多。高一的冬令营中,他开始跟周东、杨弋等选手有了较多的互动。高二的时候,他感觉自己的实力已经提升了很多。果不其然,那年的NOI他取得了第七名,成为NOI的金牌选手,并成功进入IOI集训队。   在NOI比赛中,心理素质非常重要,在激烈的竞争和名次变化中,实力很强的选手也可能会出现失误。杨沐在跟记者的交流中却一直抱着一种乐观的心态,有种望庭前花开花落,看天上云卷云舒的心态。他总是看到自己的进步和成绩,在参加比赛中,他感觉自己和同学比起来感觉自己在这方面更有天分吧!也激发了一些热情去学习信息学,我觉得是一种良性循环。     三、且将风物放眼量   高一时期的杨沐,应该还是NOI选手中不起眼的小兵。不过,铜牌的成绩对夏令营营员的他也是一种鼓励。在考试之后,杨沐在魏丽真老师的指导下,调整了自己的训练方法,改变了做题战略,他的进步突飞猛进。   他说:高一的时候做题都是做简单题,结果就没什么进步。NOI夏令营以后就改做难题了,我是做acm.sgu.ru这个题库比较多,然后就见到挺多难题,扩展了知识面,知道了一些自己原来不知道的东西。原来都不知道自己还有什么知识点没学过,后来至少知道哪些东西我还不懂可以去研究的,这样就好很多了!” NOI考试题目中注重基础,他以前做过的基础题目对他的考试很有帮助。   在高二的时候,他和其他选手的交流也达到了高峰,集训队建立了QQ群,杨沐和其他选手经常在群里交流很多问题。高二对杨沐来说,是一个厚积薄发的时期。      四、师训铭心重似山   从初二开始,杨沐就在魏丽真老师的指导下学习信息学奥赛。五年来,他和魏老师的关系已经亲近到像家人一样。而且,还有个小故事。在杨沐初中升高中的时候,他填报了福州三中作为第一志愿。可是后来杨沐的妈妈帮忙整理书堆时,却发现了一张福州一中的保送录取通知书。原来杨沐之前悄悄把通知书收起来了,这是我自己做出的决定。杨沐之所以做出这个决定,是因为魏丽真老师在福州三中任教。   杨沐说:魏老师最经常叫我做的事就是列计划,我觉得这样学习也有系统性,可能也是比较好的方法吧!     五、无限风光在险峰   在攀登信息学奥赛最高峰的过程中,杨沐说:谁都没有必胜的把握,但我想,至少我有向这个方向努力过!  在IOI比赛之前,杨沐的状态比较低迷。不过比赛的时候,他还是发挥出色。第一试拿了满分。他说:“IOI的题目一定程度上可能会引导NOI出题的趋势,今年参加IOI冬令营的选手已经有很多经验,只要调整好心态,就能取得好成绩,中国队的选手都很强。  拿到了国际信息学奥赛的金牌,杨沐感受更多的是国家的荣誉。他说:比赛获得了金牌,是我意料之中的事。中国的信息学奥赛历来就是世界最强之一,而作为中国人出了国门,就要赢!     有时我会想,如果当初并没有接触到信息学,那么我将会踏上完全不同的人生之路,将在某个领域默默奋斗着,也会有欢笑,也会有痛苦,也许会少些负担,生活得更为轻松自在。但倘若如此,我便不会遇见那些与我志同道合的朋友们,不会有如此广阔的舞台任我施展,也决不会如此近距离地去认识亲近我们那些为教育事业倾其一生的教授、老师、专家们。这些年里我学到的不仅是书本上的内容,更重要的是如何去思考,去探索。” ——杨沐在一篇小文中如此说 杨沐简介 学校:福建省福州第三中学 所获奖项:NOI 2006一等奖、APIO 2007 金牌 星座:巨蟹座 爱好:编程、听音乐等 人生梦想:保卫地球 最喜欢的颜色:紫色 最喜爱的明星:Garnet Crow 最中意的食物:福州鱼丸 最喜欢的歌曲:blue bird 最喜爱的运动:足球 最喜欢的动物:猫 最喜欢的刊物:中小学电脑报 最爱做的事情:和朋友一起玩 最高兴的事情:被选入IOI 2007国家队 最难忘的事情:第一次看《中小学电脑报》 最郁闷的事情:NOIrisk程序没被更新结果完败 座右铭 :万物殊理,道不私,故无名。无名故无为,无为而无不为。 给参加信息学奥赛的同龄人的意见和建议:好好学习,天天向上。

 

 

 

 

0

 

 

2017-04-13 17:10:37

1

64

N

2

2

0

1274

【访.谈录】成长的无限性(陈瑜希)

成长的无限性(访陈瑜希) 作者:韩晓洁 时间: 2007.10.27 文档类型/出处:NOI专刊 在男生占了绝对优势的信息学比赛中,陈瑜希脱颖而出,成为2007年信息学奥赛的最佳金牌女选手。性格随和的她,在记者拍照时会礼貌地微笑,举手投足中显示出自身的涵养。她的未来,具有发展的无限可能性。 美丽的误会   当我问陈瑜希有什么爱好时,她有些不好意思:正如我妈妈说的,我学过很多都没学出来……歌也唱不好,乐器也不会。喜欢乒乓球、羽毛球,但也都很菜。  听说你体育很好?记者不甘心地 追问。私下澄清一下啊,那是个美丽的误会。 我们学校为了增加体育节的娱乐性,组织了套圈比赛,奖品是3瓶饮料,我命中率高达80%,我们班主任印象深刻,后来就经常提起。  不过瑜希的妈妈要求她每天必须跑步或者跳绳半个小时,不能放松对体育锻炼的重视。她长久以来也养成了良好的习惯。 失败后的成功   陈瑜希印象最深刻的一次比赛是初中三年级的省队选拔。选拔之前的考试她考得都不错,所以她抱着满满的信心,但正式考试却没有发挥好,给她打击很大,她迎来了自己在信息学奥赛征程上的第一次失败。她自己总结说:也许有点盲目乐观了吧,所以想把所有题目都做好,结果就都没做好。  后来,在高一的NOIP比赛中,她从失败中走了出来。她说离不开老师和学校对她的支持。当时离中考只有一个多月。我很担心,倒不是担心中考我会考不上南外,而是担心高一的选拔我会再有类似的错误……”了解情况的老师对瑜希说:这一个半月你就在课堂上好好学,回家照样搞计算机,中考不会有问题的。这种支持对于当时的瑜希非常重要,让她在感动之余,重新找回了信心。学校领导也很支持瑜希她们出去比赛,比如在费用等方面。 磨练与成长   高一那次比赛之后,陈瑜希在信息学奥赛中的道路一直很顺利。她说:对已经过去了的事情,我有了新的认识。高一时她写过一篇作文,被老师当作了范文。她在文中写道:比赛给予了我们展示自我的舞台。让我们在磨练中成长,当然,舞台的背后是汗水和泪水,但成功的喜悦远远可以使我忘记过去的烦恼。每次把文章翻出来, 瑜希都会有新的体会。但参加信息学奥赛的日日夜夜已被嵌入她的生命里。    用平和的心态挑战   陈瑜希的话里话外给记者一种很平和的感觉,记者问她是不是一个心理素质很好的人,她笑呵呵地说:主要我对自己要求不高,反而压力小了。我妈妈说有研究表明,心理素质是天生的。  对于她来说,参加奥赛已经不仅仅因为取得好成绩有保送的资格,还因为周围人都觉得她应该出成绩。如果拿不到就会令大家失望。所有无形的压力都是需要在比赛中克服的。“NOI不仅仅需要水平,还需要良好的心理素质。学会认输 进行计算机训练,是一种严谨、细致、有连贯性的学习,做完一道题要好几个小时,沉浸其中,一定要有耐力。有时在比赛中,也会碰到平时成绩不如她的选手考得更好,陈瑜希也会郁闷,但有了学会认输的理念,她会提醒自己分析一下别人成功的道理,对自己很有启发。少说,多做,学会认输。陈瑜希觉得这句话很有道理,一直记着。   今年冬天,她就要进入国家集训队,准备明年IOI的选拔了。不过她似乎并不看好自己,集训队里强手太多了。 奥赛感受   陈瑜希谦虚地说:我没资格谈经验,和杨弋、周冬他们比起来。如果真要说的话,就是知识上要完备。考试和平时训练是不太一样的,心理上有所准备。  她平时做的题都很基础,不过她从来不会放弃别人的帮助,如果没有别人的帮助,要靠自己来解决很困难。我问她:你觉得自己属于那种基础扎实发挥稳定的选手吗?她似乎有些汗颜。我自己个人确实这么觉得啊,可是这话说出来,那些集训队的人肯定会笑我。  陈瑜希在今年信息学奥赛的一试中有点慌乱,当时觉得前两道题拿160分很简单,而第三题开始动手的时候有点偷懒,程序写好之后才发现了错误,所以后来时间就不够了。二试的时候,她拿到题目就感觉很爽啊!不过她做题动作太慢了,没来得及检查,结果有一题得零分。在陈瑜希看来,要发挥得好,有各方面的综合因素。 缘定北大   在福州的信息学奥赛结束之后,北京大学招生的负责人就与陈瑜希签了录取的相关协议。很多参加信息学奥赛的选手都会在大学里继续学习计算机专业,不过陈瑜希去北大学习数学也有自己的想法,因为数学是计算机科学的基础,也是她从小非常爱好的学科。上小学时,她就是因为数学成绩在班里比较突出,被老师推荐去少年宫学习计算机。初次比赛取得的好成绩刺激了她的兴趣,从此才一发不可收拾。   距离参加国家集训队的冬令营还有段时间,瑜希现在正准备数学的分区联赛。她在进行一次挑战自我的浩大工程,用她的话来说是拆东墙补西墙。不过,她很坚定地认为数学是基础,如果学好的话会给自己创造更宽的出路。 瑜希个人档案: 最爱吃的东西:KFC   最喜欢的歌:《隐形的翅膀》   获奖经历:2003年、2004年全国信息学联赛(NOIP)普及组 一等奖 最佳女选手        2005年、2006年全国信息学联赛(NOIP)提高组 一等奖 最佳女选手        2006年全国信息学竞赛(NOIP)银牌        2007年全国信息学竞赛(NOIP)金牌 最佳女选手 最崇拜的人:杨弋 爱好:乒乓球、羽毛球

 

 

 

 

0

 

 

2017-04-13 17:10:37

1

64

N

4

4

0

1275

【访.谈录】唐文斌与世界顶级电脑编程大赛

绍兴一中高三学生唐文斌闯入世界顶级编程决赛 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/sutdents/tangwenbing.jpg> 这是全球唯一进入决赛的中学生选手   今天上午,这名叫唐文斌的高三学生将直飞美国参赛   商报讯  今天上午,绍兴一中高三学生唐文斌将赴上海乘国际航班直飞美国。唐文斌此番赴美,参加的是一项世界顶级电脑编程比赛——美国Topcoder电脑编程锦标赛决赛。进入决赛的48名选手来自世界各地,都是电脑编程精英,而唐文斌是闯入决赛的唯一一名中学生,有人称他为全世界中学生的骄傲。   TopCoder锦标赛是由美国Topcoder公司举办,该公司在微软、AMD等著名大企业的赞助下,专业举办各类电脑赛事,以此在全球范围内发现优秀电脑人才,并择优向这些大公司推荐输送。   唐文斌家住新昌县城关镇。上初中时,他就获得过全国信息学奥林匹克竞赛浙江赛区一等奖。刚上高一,即获得全国信息学奥林匹克竞赛全国二等奖,高二时就被清华大学录取。   今年2月,唐文斌在英文网站上看到了Topcoder电脑编程锦标赛,便开始在线报名参加比赛。第一轮初赛后,成功进入全球400强。在随后的第二轮、第三轮的比赛中,他又分别进入全球200强、100强。在最近举行的半决赛中,唐文斌成功闯入了全球48强,获得赴美参加现场决赛的资格。   此次闯入决赛的华人选手共有4人,除唐文斌外,另外3人分别为清华大学博士、清华大学在读博士生和美国斯坦福大学在读博士生。   说起此项比赛,唐文斌显得比较低调,他表示,不希望通过此次比赛而留在美国工作。比赛后还是要回来的,下半年还要去念他的清华。

 

 

 

 

0

 

 

2017-04-13 17:10:37

1

64

N

3

3

0

1276

【访.谈录】楼天城and陈启峰andSweet……

楼天城教主简介: <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/sutdents/loutiancheng.jpg> “楼天城 这个孩子很有抱负新华网浙江频道920日电 (新华社记者许群 潘一峰)915 日晚上,杭州第十四中学的李建江老师与往常一样,打开了他的电子邮箱查看邮件。一封来自希腊雅典的信件让李老师的心情久久不能平静。信里说:"李老师,我 们的比赛刚刚结束。两轮考试我发挥得都还不错,第二试还拿了满分。目前名次还不知道,不过可以肯定的是我和队友都能拿到金牌。"写信的人是正是李老师的得 意门生、代表中国参加国际信息学奥林匹克竞赛的杭州第十四中学高三学生楼天城。 两天之后,新华社向全世界播发了一条新闻:"我中学生选手在国际信息学奥林匹克竞赛中全部摘金。" 消息传来,楼天城的母校、位于西子湖畔的杭州第十四中学沸腾了。 "学校注重学生的全面发展" "这个孩子有抱负,很有出息。"杭州第十四中学的赵碧野校长这样评价她的金牌学生。 杭州第十四中学是一所有着悠久历史的重点中学,其前身正是鲁迅先生教过学的"杭女师",今年10月份即将迎来百年校庆。楼天城从雅典带回的金牌,无疑是为这所学校的校庆献上了一份厚礼。 赵校长对记者说,孩子的心理很稳定,遇事不慌。在一次全国冬令营的选拔赛中,楼天城的计算机无故死机了三次。"当时清华大学的吴文 虎教授都替孩子着急了。但是天城不慌不忙,请工作人员帮忙把机器修好,又要求组委会给他延长半个小时的考试时间。"赵校长说,"那次楼天城的成绩丝毫没有 受到影响,这是非常不容易的。有时候我们大人都不一定能做得到,更何况一个才18岁的孩子。" 据赵校长介绍,学校比较注重学生的全面发展,提倡学生不偏科、不搞突击,引导学生全面发展,提高自身各方面的素质。 "像上次马晓春来学校的时候,楼天城还和同学们一起与马晓春对弈了几局。"赵校长说,"我们经常为学生创造这样的机会,让同学们多见世面。这也有助于心理素质的培养。" 赵校长告诉记者,楼天城的一些初中同学现在都没有取得像他这样的优异成绩,除了自身的原因之外,与学校的育人环境还是很有关系的。以学校计算机与信息学教研组为例,虽然平均年龄只有27岁左右,但所有教师都是党员,有过硬的教学与科研能力。   "我是第一时间知道消息的" "我应该是第一个知道他获奖消息的,15日的晚上我就收到了天城的电子邮件。"指导老师李建江显然为自己的得意门生感到非常自豪。 人们也许猜不到,李建江老师才27岁。这是一位非常年轻的中学教师。从浙江师范大学毕业之后,李老师进入杭十四中工作,2001年 起开始担任计算机竞赛的指导老师。在培养楼天城的三年时间里,李老师为楼天城制定学习计划,联系外语教师,提供上机的场地……其间付出了不少心血与汗水, 也与楼天城建立了深厚的友谊。 去年8月,楼天城参加在上海举行的全国青少年信息学竞赛。由于第一试发挥得不太理想,他的心情不是特别好。 "当时正好离第二试还有一天时间。于是我就陪着他去上海科技馆、东方明珠塔、外滩等地方游玩,尽量减轻他心里的焦虑,让他能够在第二试的时候轻装上阵。"李老师对记者说。 在那次竞赛中,楼天城取得了全国第3名的好成绩,并顺利入选国家集训队。 在李老师的悉心指导下,楼天城从高一开始就不断取得累累硕果。200111月,全国青少年信息学联赛(浙江赛区)一等奖。 20028月,全国青少年信息学竞赛三等奖。200210月,全国高中数学联赛(浙江赛区)一等奖。200211月,全国青少年信息学联赛一等奖, 浙江赛区第1名。20038月,全国青少年信息学竞赛一等奖,入选国家集训队。200310月,全国高中数学联赛一等奖。200311月,全国青少 年信息学联赛一等奖。20045月,国家队选拔赛第一名。20049月,国际信息学奥林匹克竞赛金牌,第3名。 这一张张"闪亮"的成绩单背后,凝聚了李建江老师和许许多多培养楼天城成长的老师们辛勤的劳动。 "一次,李老师因为陪同楼天城参加外地的比赛,他女朋友的腿摔坏了,也没顾得上去照顾她,"赵校长对记者说。而李老师略显"腼腆"的笑着说,这没什么,作为老师首先应该考虑学生。 "孩子人品很好,很正直" 楼天城的父母亲都是浙江大学的教师。父亲楼宇在浙大环境与资源学院任教,母亲李秀玲在理学院化学系工作。谈起孩子的成长,作母亲的自然是感触深刻。 "家里的环境很宽松,我们也很少对他提很高的要求。在家里,有什么事情,我们总是一起商量,把他也当作大人对待。" 李秀玲告诉记者,儿子初中考高中的时候获得了保送到杭州第十四中学读书的资格,我们家长当时想让他考更加好一些的学校,例如杭外或 杭二中。但是孩子认为如果保送的话,可以有三个月的自由支配时间用来学习新的知识。于是我们就尊重了孩子的选择。事实也证明孩子的选择是对的:在上高一之 前,楼天城就已经学完了高中三年的数学课程。 "像这一次,我们对他说,北大、清华、浙大、复旦、交大,都是很优秀的学校。你现在已经有了保送的资格,无论选哪一所学校,都 会有好的发展的。"李秀玲对记者说,"结果孩子选择了保送清华大学计算机科学与技术系。让孩子自己作选择的同时,也是在培养孩子独立思考问题与解决问题的 能力。" 谈到楼天城的学习,李秀玲用了两个字来评价"专心"。在上初中的时候,当时学校里中午比较吵,很多同学都在聊天或者打闹。但是楼天城却能在这样的环境中静下心来写作业。放学的时候,一些任课老师甚至对楼天城说:"路上不要思考问题,要注意安全。" 楼天城的刻苦还可以从他学计算机中看出来。在上高中以前, 楼天城甚至还没摸过电脑,这方面知识一点也没有。高中时他参加了计算机兴趣班,从此以后,他整个人似乎就沉了进去,有时到了茶饭不思的地步。如今,楼天城不仅电脑玩得溜溜转,而且还会一些复杂的编程。 虽然楼天城在学科竞赛中取得了优异的成绩,但是最让母亲值得骄傲的也许并不是这些金牌与获奖证书。李秀玲告诉记者,天城的人品很 好,很正直。一次在清华大学,李秀玲对儿子说:"你能不能用自行车带妈妈一段,妈妈走累了。"楼天城对母亲说:"妈妈,校园里不能骑车带人的,清华大学有 这个规定。我们不能违反规定。就像考试作弊一样,是不可以做的事情。"这件事情让李秀玲感慨了好一阵子,同时也为孩子的人品而骄傲。 李秀玲对记者表示,希望儿子在以后的学习与工作中能够不断创新。 这,就是父母亲对楼天城的期望 [楼天城 (ACRush)] 86年出生 高中以前几乎没摸过电脑 200111月,全国青少年信息学联赛(浙江赛区)一等奖。 20028月,全国青少年信息学竞赛三等奖。 200210月,全国高中数学联赛(浙江赛区)一等奖。 200211月,全国青少年信息学联赛一等奖,浙江赛区第1名。 20038月,全国青少年信息学竞赛一等奖,入选国家集训队。 200310月,全国高中数学联赛一等奖。 200311月,全国青少年信息学联赛一等奖。 20045月,国家队选拔赛第一名。 20049月,国际信息学奥林匹克竞赛金牌,第3名。 2005-2006年,2005百度之星程序设计大赛冠军。        2006百度之星程序设计大赛冠军。        google编程挑战赛第三名。        TopCoder算法中国区第一名。 还说能一个人单挑一支队 牛得简直没话说了 这个孩子很有抱负记国际信息学奥林匹克竞赛金牌获得者搂天城 新华网杭州926日电(记者许群潘一峰)915日晚上,杭州第十四中学的李建江老师与往常一样,打开了他的电子邮箱查看邮件。一封来自希腊雅典的信件让李老师的心情久久不能平静。信里说:李老师,我们的比赛刚刚结束。两轮考试我发挥得都还不错,第二试还拿了满分。目前名次还不知道,不过可以肯定的是我和队友都能拿到金牌。写信的人正是李老师的学生、代表中国参加第16届中学生国际信息学奥林匹克竞赛的杭州第十四中学高三学生楼天城。 播发了一条新闻:我中学生选手在国际信息学奥林匹克竞赛中全部摘金。   消息传来,楼天城的母校、位于西子湖畔的杭州第十四中学沸腾了。   学校注重学生的全面发展   这个孩子有抱负,很有出息。杭州第十四中学的赵碧野校长这样评价她的金牌学生。   杭州第十四中学是一所有着悠久历史的重点中学,其前身正是鲁迅先生教过学的杭女师,今年10月,杭州第十四中学即将迎来百年校庆。楼天城从雅典带回的金牌,无疑为百年校庆献上了一份厚礼。   赵碧野对记者说,孩子的心理很稳定,遇事不慌。在一次全国冬令营的选拔赛中,楼天城的计算机无故死机了三次。当时清华大学的吴文虎教授都替孩子着急了。但是天城不慌不忙,请工作人员帮忙把机器修好,又要求组委会给他延长半个小时的考试时间。赵校长说,那次楼天城的成绩丝毫没有受到影响,这是非常不容易的。有时候我们大人都不一定能做得到,更何况一个18岁的孩子。   据赵碧野介绍,学校比较注重学生的全面发展,提倡学生不偏科、不搞突击,引导学生全面发展,提高自身各方面的素质。   像上次马晓春来学校的时候,楼天城还和同学们一起与马晓春对弈了几局。赵碧野说,我们经常为学生创造这样的机会,让同学们多见世面。这也有助于心理素质的培养。   赵碧野告诉记者,楼天城能取得这样的优异成绩,除了自身的原因之外,学校的育人环境也很重要。以学校计算机与信息学教研组为例,虽然教师的平均年龄只有27岁左右,但都有过硬的教学与科研能力。   我是第一时间知道消息的   我应该是第一个知道他获奖消息的,15日晚上我就收到了天城的电子邮件。指导老师李建江为自己的得意门生感到非常自豪。   李建江今年27岁,从浙江师范大学毕业之后,李老师进入杭州第十四中学工作,2001年起开始担任计算机竞赛的指导老师。在培养楼天城的三年时间里,李老师为楼天城制定学习计划,联系外语教师,提供上机场地……其间付出了不少心血与汗水,也与楼天城建立了深厚的友谊。   去年8月,楼天城参加在上海举行的全国青少年信息学竞赛。由于第一试发挥得不太理想,他的心情不是特别好。   当时正好离第二试还有一天时间。于是我就陪着他去上海科技馆、东方明珠塔、外滩等地方游玩,尽量减轻他心里的焦虑,让他能够在第二试的时候轻装上阵。李老师对记者说。   在那次竞赛中,楼天城取得了全国第3名的好成绩,并顺利入选国家集训队。   在李老师的悉心指导下,楼天城从高一开始硕果累累。200111月,全国青少年信息学联赛(浙江赛区)一等奖;20028月,全国青少年信息学竞赛三等奖;200210月,全国高中数学联赛(浙江赛区)一等奖;200211月,全国青少年信息学联赛一等奖,浙江赛区第一名;20038月,全国青少年信息学竞赛一等奖,入选国家集训队;200310月,全国高中数学联赛一等奖;200311月,全国青少年信息学联赛一等奖;20045月,国家队选拔赛第一名;20049月,国际信息学奥林匹克竞赛金牌,第3名。这一张张闪亮的成绩单背后,凝聚了李建江老师和许许多多培养楼天城成长的老师们辛勤的劳动。   让孩子自己作出选择   楼天城的父母亲都是浙江大学的教师。父亲楼宇在浙大环境与资源学院任教,母亲李秀玲在理学院化学系工作。谈起孩子的成长,作母亲的自然是感触颇深。   家里的环境很宽松,我们也很少对他提很高的要求。在家里,有什么事情,我们总是一起商量,把他也当作大人对待。   李秀玲告诉记者,儿子初中考高中的时候获得了保送到杭州第十四中学读书的资格,我们家长当时想让他考更加好一些的学校,例如杭外或杭二中。但是孩子认为如果保送的话,可以有三个月的自由支配时间用来学习新的知识。于是我们就尊重了孩子的选择。事实也证明孩子的选择是对的:在上高一之前,楼天城就已经学完了高中三年的数学课程。   这一次,我们对他说,北大、清华、浙大、复旦、交大,都是很优秀的学校。你现在已经有了保送的资格,无论选哪一所学校,都会有好的发展。李秀玲对记者说,结果孩子选择了保送清华大学计算机科学与技术系。让孩子自己作选择的同时,也是在培养孩子独立思考问题与解决问题的能力。   谈到楼天城的学习,李秀玲用了两个字来评价-专心。在上初中的时候,当时学校里中午比较吵,很多同学都在聊天或者打闹。但是楼天城却能在这样的环境中静下心来写作业。放学的时候,一些任课老师甚至对楼天城说:路上不要思考问题,要注意安全。   楼天城的刻苦还可以从他学计算机中看出来。在上高中以前,楼天城甚至没有摸过电脑,这方面知识一点也没有。高中时他参加了计算机兴趣班,从此以后,他整个人似乎就沉了进去,有时到了茶饭不思的地步。如今,楼天城不仅电脑玩得溜溜转,而且还会编一些复杂的程序。   虽然楼天城在学科竞赛中取得了优异的成绩,但是最让母亲骄傲的也许并不是这些金牌与获奖证书。李秀玲告诉记者,天城的人品很好,很正直。一次在清华大学,李秀玲对儿子说:你能不能用自行车带妈妈一段,妈妈走累了。楼天城对母亲说:妈妈,校园里不能骑车带人,清华大学有这个规定。我们不能违反规定。就像考试作弊一样,是不可以做的事情。这件事让李秀玲感慨了好一阵子,同时也为孩子的人品而骄傲。   楼天城将于23日回到杭州。李秀玲对记者表示,希望儿子在以后的学习与工作中不断创新。这,就是父母亲对楼天城的期望。(来源:新华网) 天牛CQF: 陈启峰是中山市纪念中学的学生,今年813日,陈启峰与国家队另外三名选手一起出征克罗地亚,最终获得全世界第八名的优秀成绩,为广东省填补了没有国际信息学奥赛金牌的空白。 成绩三次夺得全国信息学决赛冠军 据陈启峰的老师介绍,陈启峰初一的时候才接触信息学,在短短的四年间,启峰一直在打破各种纪录中不断提高自己的水平,在他获得国际奥赛金牌前已经三次夺得了全国信息学决赛的金牌。 2005年启峰在省队选拔赛中以第一名成绩入选广东省队,在全国决赛中获得金牌,这也是当时全国唯一一个获得金牌的初中选手,同时也是广东省第一个获得国家金牌的初中生。 在2006年的广东省队选拔赛中,他再次以全省第一名的成绩入选广东省队,在全国决赛中再次以全国第四名的成绩获得金牌,入选国家集训队。 在2007年的国家队选拔赛第一试中启峰获得第一名,在5月份的国家队选拔赛中他最终以全国第二名的成绩入选中国国家队,打破了中山学生未能进入中国国家队的纪录。在今年7月举行的全国决赛中他再次获得金牌,成为名副其实的三连冠。 此外,早在初三的时候,陈启峰就获得了保送清华的资格。   经验不断努力,不断反思,不断进步 据陈启峰的妈妈介绍,陈启峰小时候比较特别,爱动脑筋,想法跟其他小孩不太一样。小的时候我们给他买了个拼图拼机器人,但他和其他小孩不一样,不是直接拼机器人,而是把它拼成一个拖车,可以拉书包。陈启峰的妈妈笑道。 等陈启峰上初中后,妈妈发现,陈启峰对电脑产生了浓厚兴趣。但他不是玩电脑游戏,而是拆电脑,或者删掉电脑的程序。他刚开始对电脑的组装很感兴趣,后来对电脑的程序设计也产生了兴趣。陈启峰的妈妈回忆道。 刚开始陈启峰的妈妈担心启峰会沉迷在电脑中耽误学习,后来看到启峰并没有因为玩电脑而影响学业,就干脆在启峰初一的暑假把他送到纪中参加信息学奥赛竞赛。在纪中的指导下,陈启峰开始了自己的金牌之路。 许多人都觉得陈启峰的成功很大原因与天赋有关,但他并不觉得自己很有天赋。当记者问他成功的原因时,他说的第一个原因就是自己的努力。初三启峰在纪中训练时,创下了四个月完成400多道题的罕见纪录。一般的选手一道题要花上两个多小时,但他居然能在四个月就完成了400多道题,这是相当不容易的。纪中校长贺优琳说道。 谈到自己这个纪录时,陈启峰显得很平静。那时候我做题做到深更半夜,因为我对信息学感兴趣,所以不觉得累。谈到学习方法,陈启峰扶了扶眼镜笑道:我的学习方法其实很简单,就是不断努力,不断反思。只有反思才能让人不断进步。”() orzorz……再看看我…… 上面相应提到的RP我确信没问题(有时有些不良,忍了吧诸位看官),才智至少还有,理想也很远大,还是训练不够刻苦…… 经过一段时间和天津OI界其他选手的接触,我发现了……的确都比我强一些,但他们都不是NP完全的,只要经过严厉的训练,就能超越。 sweet之野望:真正难缠的……NxunJLgeniusqi算半个,其他人只能说比我强一点,选拔赛之前可以超越,选拔赛之后,就要代表天津队出战,挑战全国高手了,Fightsweet

 

 

 

 

0

 

 

2017-04-13 17:10:37

1

64

N

3

3

0

1277

【访.谈录】我校蒋勇谈学习之道

每个人都是不同的,所谓的学习方法也只有适合自己才能算作好方法,照搬别人经验肯定不太好,但借鉴一下还是挺好的。 下面我就谈谈我的学习OI的过程: 我也是很迟了才接触这门竞赛,开始学的也不怎么样。但有一段我们好像每个星期六下午都在那个破机房里学习(电脑还是我自己在老师帮助下亲身组装的),那里的电脑安装的都是DOS系统,我们除了会几个简单的进入操作其余都不会,所以只好老老实实编程,可我也不得不承认这种学习环境下效率是很高的,不久我们(老实说不能说是我们,因为只有三个人,星期六愿意来的又有几个呢?)就把那本黄皮书做完了,老师又给我们买了一本《计算机程序设计》。但从那些天以后,我们的效率又陷入了低谷(这就像连锁效应),我一个学期才学完100页,我现在想想就后悔。一个学期啊,就这样白白浪费了! 但高一的暑假是一个新的开始。我就简称它为暑假攻略。 高一期末考结束的那天下午,我就跟老师去温州参加夏令营即省队选拔赛,那个时候我连深搜跟广搜都还不明白,但那几天对我的影响绝对是巨大的,我们白天去听那些大牛们讲课,虽然什么都不懂,但晚上大家一起讨论后,收获还是很大的,可以说是日进千里,我曾经发出感慨——如果这样学习个一个月,我就有信心把一等拿回来。但我觉得真正的收获是这几天学习激发了我心里的渴望——一年后我要真正坐在这里参加省队选拔赛。 从温州回来没几天,我又去金华参加物理夏令营了。回来后,已是720日了。接下来的十天,我基本上每天都从早到晚做作业。十天过后,我终于把全部暑假作业通杀了。下面一个月,我开始了像武侠小说里的人一样的闭关修炼。在这一个月里,白天我疯狂的做TJU上的题目,碰到不会做的题目就看别人的,看不懂就背;晚上绝不碰电脑,一心一意看《程序设计》这本书,理解上面的例题,理解不了就背,还有上面的习题也一道一道做过去,碰到不会的画个圈,跳过去再说。……一个月过去了,我在TJU上做了60多道,一知半解的学完了《程序设计》这本书。暑假回来后,我的拿一等的信心大增,而他们几个却把暑假白白浪费了,这个时候我跟他们已经是两个不同的等级了。 …… …… 最后我用一副对联与大家共勉: 有志者,事竟成,破釜沉舟,百二秦关终属楚; 苦心人,天不负,卧薪尝胆,三千越甲可吞吴。 2005年蒋勇获全国三等奖,我校共有三人参加初赛辅导,仅蒋勇进入第二轮(另:杨加波、车凌宾获市级以上奖)。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/sutdents/2005.gif> 2006年蒋勇获全国一等奖,获高考保送及加20分资格,后进入大连海事大学学习。 我校共有6人参加初赛辅导(另:金士杰(高二)、蒋昱昱(高一)、陈立红、徐力、胡晓样获市级奖)。 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/sutdents/2006.gif> 2007年林志华 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/sutdents/2007.gif> 2002蔡啸(高一) <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/sutdents/2002.gif> 2003蔡啸(高二)获全国信息学一等奖,取得浙江省第九名好成绩。 获高考保送及加20分资格,后进入北京大学学习 <img border=0 src=http://10.10.10.3:8080/JudgeOnline/images/sutdents/2003.gif>

 

 

 

 

0

 

 

2017-04-13 17:10:37

1

64

N

4

6

0

1278

USACO_2.3-2:Cow Pedigrees奶牛家谱

农民约翰准备购买一群新奶牛。 在这个新的奶牛群中, 每一个母亲奶牛都生两小奶牛。这些奶牛间的关系可以用二叉树来表示。这些二叉树总共有N个节点(3 <= N < 200)。这些二叉树有如下性质: 每一个节点的度是02。度是这个节点的孩子的数目。 树的高度等于K(1 < K < 100)。高度是从根到任何叶子的最长的路径上的节点的数目; 叶子是指没有孩子的节点。 有多少不同的家谱结构? 如果一个家谱的树结构不同于另一个的, 那么这两个家谱就是不同的。输出可能的家谱树的个数除以9901的余数。

PROGRAM NAME: nocows 1: 两个空格分开的整数, NK

 1 : 一个整数,表示可能的家谱树的个数除以9901的余数。

SAMPLE INPUT (file nocows.in) 5 3

SAMPLE OUTPUT (file nocows.out) 2 5个节点,高为3的两个不同的家谱: @ @ / \ / \ @ @  @ @ / \ / \ @ @ @ @

0

 

USACO_2.3-2:Cow Pedigrees奶牛家谱

2017-04-13 17:10:37

1

64

N

0

2

0

1279

USACO_2.3-3:zerosum零的算式和

请考虑一个由1NN=3, 4, 5 ... 9)的数字组成的递增数列:1 2 3 ... N。现在请在数列中插入“+”表示加,或者“-”表示减,抑或是“ ”表示空白,来将每一对数字组合在一起(请不在第一个数字前插入符号)。计算该表达式的结果并注意你是否得到了和为零。请你写一个程序找出所有产生和为零的长度为N的数列。

PROGRAM NAME: zerosum 单独的一行表示整数N (3 <= N <= 9)

按照ASCII码的顺序,输出所有在每对数字间插入“+”, “-”,  “ ”后能得到和为零的数列。

7

1+2-3+4-5-6+7 1+2-3-4+5+6-7 1-2 3+4+5+6+7 1-2 3-4 5+6 7 1-2+3+4-5+6-7 1-2-3-4-5+6+7

0

 

USACO_2.3-3:zerosum零的算式和

2017-04-13 17:10:37

1

64

N

2

2

0

1280

USACO_2.3-4:Money Systems货币系统

母牛们不但创建了他们自己的政府而且选择了建立了自己的货币系统。由于他们特殊的思考方式,他们对货币的数值感到好奇。 传统地,一个货币系统是由1,5,10,20  25,50,  100的单位面值组成的。 母牛想知道有多少种不同的方法来用货币系统中的货币来构造一个确定的数值。 举例来说, 使用一个货币系统 {1,2,5,10,...}产生 18单位面值的一些可能的方法是:18x1, 9x2, 8x2+2x1, 3x5+2+1,等等其它。写一个程序来计算有多少种方法用给定的货币系统来构造一定数量的面值。保证总数将会适合long long (C/C++)  Int64 (Free Pascal)

PROGRAM NAME: money (file money.in) 货币系统中货币的种类数目是 V (1<= V<=25)。要构造的数量钱是 N (1<= N<=10,000)。 第 1 : 二整数, V  N  2 行: 可用的货币 V 个整数。

(file money.out) 单独的一行包含那个可能的构造的方案数。

3 10 1 2 5

10

0

 

USACO_2.3-4:Money Systems货币系统

2017-04-13 17:10:37

1

64

N

1

3

0

1281

USACO_2.3-5:Controlling Companies控制公司

有些公司是其他公司的部分拥有者,因为他们获得了其他公司发行的股票的一部分。例如,福特公司拥有马自达公司12%的股票。据说,如果至少满足了以下三个条件之一,公司A就可以控制公司B了: (I)、公司A = 公司B。 (II)、公司A拥有大于50%的公司B的股票。 (III)、公司A控制K(K >= 1)个公司,记为C1, ..., CK,每个公司Ci拥有xi%的公司B的股票,并且x1+ .... + xK > 50%。 给你一个表,每行包括三个数(i,j,p);表明公司i享有公司jp%的股票。计算所有的数对(hs),表明公司h控制公司s。至多有100个公司。 写一个程序读入三对数(ijp),ijp是都在范围(1..100)的正整数,并且找出所有的数对(hs),使得公司h控制公司s

PROGRAM NAME: concom (file concom.in) 第一行: N,表明接下来三对数的数量。{即(i,j,p)的数量} 第二行到第N+1行: 每行三个整数作为一个三对数(ijp),如上文所述。{表示公司 i 拥有公司j p%的股份}

file concom.out 输出零个或更多个的控制其他公司的公司。每行包括两个整数AB,表示A公司控制了B公司。将输出的数对以升序排列。 请不要输出控制自己的公司。

3 1 2 80 2 3 80 3 1 20

1 2 1 3 2 3

0

 

USACO_2.3-5:Controlling Companies控制公司

2017-04-13 17:10:37

1

64

N

2

2

0

1282

USACO教程:Shortest Paths最短路径

<body> <font face='Verdana,Tahoma,sans-serif,Arial,Lucida Sans,Gill Sans'> <h4>Sample Problem: Overfencing [Kolstad & Schrijvers, Spring 1999 USACO Open]</h5> <p> Farmer John created a huge maze of fences in a field. He omitted two fence segments on the edges, thus creating two ``exits'' for the maze. The maze is a `perfect' maze; you can find a way out of the maze from any point inside it. <p> Given the layout of the maze, calculate the number of steps required to exit the maze from the `worst' point in the maze (the point that is `farther' from either exit when walking optimally to the closest exit). <p> Here's what one particular W=5, H=3 maze looks like: <br> <tt><font size='2'> <br> +-+-+-+-+-+<br> |         |<br> +-+ +-+ + +<br> |     | | |<br> + +-+-+ + +<br> | |     |  <br> +-+ +-+-+-+<br> </font></tt> <h4>The Abstraction</h5> <p> Given: <ul> <li>A directed graph with nonnegative weighted edges</li> <li> A path between two vertices of a graph is any sequence of adjacent edges joining them </li> <li> The shortest path between two vertices in a graph is the path which has minimal cost, where cost is the sum of the weights of edges in the path.</li> </ul> <p> Problems often require only the cost of a shortest path not necessarily the path itself. This sample problem requires calculating only the costs of shortest paths between exits and interior points of the maze. Specifically, it requires the maximum of all of those various costs. <h4>Dijkstra's algorithm to find shortest paths in a weighted graph</h5> <p> Given: lists of vertices, edges, and edge costs, this algorithm `visits' vertices in order of their distance from the source vertex. <ul> <li> Start by setting the distance of all notes to infinity and the source's distance to 0.</li> <li> At each step, find the vertex u of minimum distance that hasn't been processed already. This vertex's distance is now frozen as the minimal cost of the shortest path to it from the source.</li> <li> Look at appending each neighbor v of vertex u to the shortest path to u. Check vertex v to see if this is a better path than the current known path to v. If so, update the best path information. </li> </ul> <p> In determining the shortest path to a particular vertex, this algorithm determines all shorter paths from the source vertex as well since no more work is required to calculate <i>all</i> shortest paths from a single source to vertices in a graph. <p> Reference: Chapter 25 of [Cormen, Leiserson, Rivest] <p> Pseudocode: <br> <tt><font size='2'> <br> # distance(j) is distance from source vertex to vertex j<br> # parent(j) is the vertex that precedes vertex j in any shortest path<br> #                  (to reconstruct the path subsequently) <br><br>  1 For all nodes i<br>  2     distance(i) = infinity          # not reachable yet<br>  3     visited(i) = False<br>  4     parent(i) = nil # no path to vertex yet <br><br>  5 distance(source) = 0 # source -> source is start of all paths<br>  6 parent(source) = nil<br>  7   8 while (nodesvisited < graphsize)<br>  9     find unvisited vertex with min distance to source; call it vertex i<br> 10     assert (distance(i) != infinity, "Graph is not connected") <br><br> 11     visited(i) = True # mark vertex i as visited <br><br>     # update distances of neighbors of i<br> 12     For all neighbors j of vertex i<br> 13         if distance(i) + weight(i,j) < distance(j) then<br> 14             distance(j) = distance(i) + weight(i,j)<br> 15             parent(j) = i<br> </font></tt> <p> Running time of this formulation is O(<i>V</i><sup>2</sup>). You can obtain O(<i>E</i> log <i>V</i>) (where <i>E</i> is the number of edges and <i>V</i> is the number of vertices) by using a heap to determine the next vertex to visit, but this is considerably more complex to code and only appreciably faster on large, sparse graphs. <h4>Sample Algorithm Execution</h5> <p> Consider the graph below, whose edge weights can be expressed two different ways: <table id="table1"> <tr> <td> <br><img src="http://10.208.83.181:80/JudgeOnline/admin/../images/1282/sp.exec1.gif"><br> <td>         <td> <center> <table id="table2"> <tr><td>Edge</td> <td>Weight</td></tr> <tr><td align="center">(1, 3)</td> <td align="center">5</td></tr> <tr><td align="center">(1, 4)</td> <td align="center">8</td></tr> <tr><td align="center">(3, 4)</td> <td align="center">2</td></tr> <tr><td align="center">(3, 5)</td> <td align="center">3</td></tr> <tr><td align="center">(4, 2)</td> <td align="center">3</td></tr> <tr><td align="center">(4, 6)</td> <td align="center">7</td></tr> <tr><td align="center">(5, 2)</td> <td align="center">6</td></tr> <tr><td align="center">(2, 6)</td> <td align="center">2</td></tr> </table> </center> </td><td> <center> <table id="table3"> <tr><td align="center"> </td> <td align="center">1</td> <td align="center">2</td> <td align="center">3</td> <td align="center">4</td> <td align="center">5</td> <td align="center">6</td></tr> <tr><td align="center">1</td> <td align="center">0</td> <td align="center">0</td> <td align="center">5</td> <td align="center">8</td> <td align="center">0</td> <td align="center">0</td></tr> <tr><td align="center">2</td> <td align="center">0</td> <td align="center">0</td> <td align="center">0</td> <td align="center">3</td> <td align="center">6</td> <td align="center">2</td></tr> <tr><td align="center">3</td> <td align="center">5</td> <td align="center">0</td> <td align="center">0</td> <td align="center">2</td> <td align="center">3</td> <td align="center">0</td></tr> <tr><td align="center">4</td> <td align="center">8</td> <td align="center">3</td> <td align="center">2</td> <td align="center">0</td> <td align="center">0</td> <td align="center">7</td></tr> <tr><td align="center">5</td> <td align="center">0</td> <td align="center">6</td> <td align="center">3</td> <td align="center">0</td> <td align="center">0</td> <td align="center">0</td></tr> <tr><td align="center">6</td> <td align="center">0</td> <td align="center">2</td> <td align="center">0</td> <td align="center">7</td> <td align="center">0</td> <td align="center">0</td></tr> </table> </center> </tr></table> <p> Here is the initial state of the program, both graphically and in a table: <table id="table4"> <tr><td> <img src="http://10.208.83.181:80/JudgeOnline/admin/../images/1282/sp.exec2.gif" valign="top"> <td> <center> <table border="1" id="table5"> <tr> <td align="center"></td align="center"> <td align="center"></td align="center"> <td align="center">Distance to</td align="center"> <td align="center"></td align="center"> </tr> <tr> <td align="center">Node</td align="center"> <td align="center">Visited</td align="center"> <td align="center">Source</td align="center"> <td align="center">Parent</td align="center"> </tr> <tr> <td align="center">1</td align="center"> <td align="center">T</td align="center"> <td align="center">0</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">2</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">3</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">4</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">5</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">6</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> </table> </center> </table> <table id="table6"> <tr><td width="200"> Updating the table, node 1's neighbors include nodes 3 and 4. <td> <center> <table border="1" id="table7"> <tr> <td align="center"></td align="center"> <td align="center"></td align="center"> <td align="center">Distance to</td align="center"> <td align="center"></td align="center"> </tr> <tr> <td align="center">Node</td align="center"> <td align="center">Visited</td align="center"> <td align="center">Source</td align="center"> <td align="center">Parent</td align="center"> </tr> <tr> <td align="center">1</td align="center"> <td align="center">T</td align="center"> <td align="center">0</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">2</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">3</td align="center"> <td align="center">F</td align="center"> <td align="center"><b>5</b></td align="center"> <td align="center"><b>1</b></td align="center"> </tr> <tr> <td align="center">4</td align="center"> <td align="center">F</td align="center"> <td align="center"><b>8</b></td align="center"> <td align="center"><b>1</b></td align="center"> </tr> <tr> <td align="center">5</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">6</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> </table> </center> </table> <p> Node 3 is the closest unvisited node to the source node (smallest distance shown in column 3), so it is the next visited: <table id="table8"> <tr><td> <img src="http://10.208.83.181:80/JudgeOnline/admin/../images/1282/sp.exec3.gif"> <td> <center> <table border="1" id="table9"> <tr> <td align="center"></td align="center"> <td align="center"></td align="center"> <td align="center">Distance to</td align="center"> <td align="center"></td align="center"> </tr> <tr> <td align="center">Node</td align="center"> <td align="center">Visited</td align="center"> <td align="center">Source</td align="center"> <td align="center">Parent</td align="center"> </tr> <tr> <td align="center">1</td align="center"> <td align="center">T</td align="center"> <td align="center">0</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">2</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">3</td align="center"> <td align="center"><b>T</b></td align="center"> <td align="center">5</td align="center"> <td align="center">1</td align="center"> </tr> <tr> <td align="center">4</td align="center"> <td align="center">F</td align="center"> <td align="center">8</td align="center"> <td align="center">1</td align="center"> </tr> <tr> <td align="center">5</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">6</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> </table> </center> </table> <table id="table10"> <tr><td width="200"> Node 3's neighbors are nodes 1, 4, and 5. Updating the unvisited neighbors yields: <td> <center> <table border="1" id="table11"> <tr> <td align="center"></td align="center"> <td align="center"></td align="center"> <td align="center">Distance to</td align="center"> <td align="center"></td align="center"> </tr> <tr> <td align="center">Node</td align="center"> <td align="center">Visited</td align="center"> <td align="center">Source</td align="center"> <td align="center">Parent</td align="center"> </tr> <tr> <td align="center">1</td align="center"> <td align="center">T</td align="center"> <td align="center">0</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">2</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">3</td align="center"> <td align="center">T</td align="center"> <td align="center">5</td align="center"> <td align="center">1</td align="center"> </tr> <tr> <td align="center">4</td align="center"> <td align="center">F</td align="center"> <td align="center"><b>7</b></td align="center"> <td align="center"><b>3</b></td align="center"> </tr> <tr> <td align="center">5</td align="center"> <td align="center">F</td align="center"> <td align="center"><b>8</b></td align="center"> <td align="center"><b>3</b></td align="center"> </tr> <tr> <td align="center">6</td align="center"> <td align="center">F</td align="center"> <td align="center">infinity</td align="center"> <td align="center">nil</td align="center"> </tr> </table> </center> </table> <p>Node 4 is the closest unvisited node to the source. Its neighbors are 1, 2, 3, and 6, of which only nodes 2 and 6 need be updated, since the others have already been visited: <table id="table12"> <tr> <td> <img src="http://10.208.83.181:80/JudgeOnline/admin/../images/1282/sp.exec4.gif"> <td> <center> <table border="1" id="table13"> <tr> <td align="center"></td align="center"> <td align="center"></td align="center"> <td align="center">Distance to</td align="center"> <td align="center"></td align="center"> </tr> <tr> <td align="center">Node</td align="center"> <td align="center">Visited</td align="center"> <td align="center">Source</td align="center"> <td align="center">Parent</td align="center"> </tr> <tr> <td align="center">1</td align="center"> <td align="center">T</td align="center"> <td align="center">0</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">2</td align="center"> <td align="center">F</td align="center"> <td align="center"><b>10</b></td align="center"> <td align="center"><b>4</b></td align="center"> </tr> <tr> <td align="center">3</td align="center"> <td align="center">T</td align="center"> <td align="center">5</td align="center"> <td align="center">1</td align="center"> </tr> <tr> <td align="center">4</td align="center"> <td align="center"><b>T</b></td align="center"> <td align="center">7</td align="center"> <td align="center">3</td align="center"> </tr> <tr> <td align="center">5</td align="center"> <td align="center">F</td align="center"> <td align="center">8</td align="center"> <td align="center">3</td align="center"> </tr> <tr> <td align="center">6</td align="center"> <td align="center">F</td align="center"> <td align="center"><b>14</b></td align="center"> <td align="center"><b>4</b></td align="center"> </tr> </table> </center> </table> <p>Of the three remaining nodes (2, 5, and 6), node 5 is closest to the source and should be visited next. Its neighbors include nodes 3 and 2, of which only node 2 is unvisited. The distance to node 2 via node 5 is 14, which is longer than the already listed distance of 10 via node 4, so node 2 is not updated. <table id="table14"><tr><td> <img src="http://10.208.83.181:80/JudgeOnline/admin/../images/1282/sp.exec5.gif"> <td> <center> <table border="1" id="table15"> <tr> <td align="center"></td align="center"> <td align="center"></td align="center"> <td align="center">Distance to</td align="center"> <td align="center"></td align="center"> </tr> <tr> <td align="center">Node</td align="center"> <td align="center">Visited</td align="center"> <td align="center">Source</td align="center"> <td align="center">Parent</td align="center"> </tr> <tr> <td align="center">1</td align="center"> <td align="center">T</td align="center"> <td align="center">0</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">2</td align="center"> <td align="center">F</td align="center"> <td align="center">10</td align="center"> <td align="center">4</td align="center"> </tr> <tr> <td align="center">3</td align="center"> <td align="center">T</td align="center"> <td align="center">5</td align="center"> <td align="center">1</td align="center"> </tr> <tr> <td align="center">4</td align="center"> <td align="center">T</td align="center"> <td align="center">7</td align="center"> <td align="center">3</td align="center"> </tr> <tr> <td align="center">5</td align="center"> <td align="center"><b>T</b></td align="center"> <td align="center">8</td align="center"> <td align="center">3</td align="center"> </tr> <tr> <td align="center">6</td align="center"> <td align="center">F</td align="center"> <td align="center">14</td align="center"> <td align="center">4</td align="center"> </tr> </table> </center> </table> <p>The closest of the two remaining nodes is node 2, whose neighbors are nodes 4, 5, and 6, of which only node 6 is unvisited. Furthermore, node 6 is now closer, so its entry must be updated: <table id="table16"><tr><td> <img src="http://10.208.83.181:80/JudgeOnline/admin/../images/1282/sp.exec6.gif"> <td> <center> <table border="1" id="table17"> <tr> <td align="center"></td align="center"> <td align="center"></td align="center"> <td align="center">Distance to</td align="center"> <td align="center"></td align="center"> </tr> <tr> <td align="center">Node</td align="center"> <td align="center">Visited</td align="center"> <td align="center">Source</td align="center"> <td align="center">Parent</td align="center"> </tr> <tr> <td align="center">1</td align="center"> <td align="center">T</td align="center"> <td align="center">0</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">2</td align="center"> <td align="center"><b>T</b></td align="center"> <td align="center">10</td align="center"> <td align="center">4</td align="center"> </tr> <tr> <td align="center">3</td align="center"> <td align="center">T</td align="center"> <td align="center">5</td align="center"> <td align="center">1</td align="center"> </tr> <tr> <td align="center">4</td align="center"> <td align="center">T</td align="center"> <td align="center">7</td align="center"> <td align="center">3</td align="center"> </tr> <tr> <td align="center">5</td align="center"> <td align="center">T</td align="center"> <td align="center">8</td align="center"> <td align="center">3</td align="center"> </tr> <tr> <td align="center">6</td align="center"> <td align="center">F</td align="center"> <td align="center"><b>12</b></td align="center"> <td align="center"><b>2</b></td align="center"> </tr> </table> </center> </table> <p>Finally, only node 6 remains to be visited. All of its neighbors (indeed the entire graph) have now been visited: <table id="table18"><tr><td> <img src="http://10.208.83.181:80/JudgeOnline/admin/../images/1282/sp.exec7.gif"> <td> <center> <table border="1" id="table19"> <tr> <td align="center"></td align="center"> <td align="center"></td align="center"> <td align="center">Distance to</td align="center"> <td align="center"></td align="center"> </tr> <tr> <td align="center">Node</td align="center"> <td align="center">Visited</td align="center"> <td align="center">Source</td align="center"> <td align="center">Parent</td align="center"> </tr> <tr> <td align="center">1</td align="center"> <td align="center">T</td align="center"> <td align="center">0</td align="center"> <td align="center">nil</td align="center"> </tr> <tr> <td align="center">2</td align="center"> <td align="center">T</td align="center"> <td align="center">10</td align="center"> <td align="center">4</td align="center"> </tr> <tr> <td align="center">3</td align="center"> <td align="center">T</td align="center"> <td align="center">5</td align="center"> <td align="center">1</td align="center"> </tr> <tr> <td align="center">4</td align="center"> <td align="center">T</td align="center"> <td align="center">7</td align="center"> <td align="center">3</td align="center"> </tr> <tr> <td align="center">5</td align="center"> <td align="center">T</td align="center"> <td align="center">8</td align="center"> <td align="center">3</td align="center"> </tr> <tr> <td align="center">6</td align="center"> <td align="center"><b>T</b></td align="center"> <td align="center">12</td align="center"> <td align="center">2</td align="center"> </tr> </table> </center> </table> <h5> Sample Problem: Package Delivery </h5> <p> Given a set of locations, lengths of roads connecting them, and an ordered list of package dropoff locations. Find the length of the shortest route that visits each of the package dropoff locations in order. <p> Analysis: For each leg of the required path, run Dijkstra's algorithm to determine the shortest path connecting the two endpoints. If the number of legs in the journey exceeds N, instead of calculating each path, calculate the shortest path between all pairs of vertices, and then simply paste the shortest path for each leg of the journey together to get the entire journey. <h5> Extended Problem: All Pairs, Shortest Paths </h5> <p> The extended problem is to determine a table <i>a</i>, where:<br> <i>a<sub>i,j</sub></i> = length of shortest path between <i>i</i> and <i>j</i>, or infinity if <i>i</i> and <i>j</i> aren't connected. <p> This problem is usually solved as a subproblem of a larger problem, such as the package delivery problem. <p> Dijkstra's algorithm determines shortest paths for one source and all destinations in O(<i>N</i><sup>2</sup>) time. We can run it for all <i>N</i> sources in O(<i>N</i><sup>3</sup>) time. <p> If the paths do not need to be recreated, there's an even simpler solution that also runs in O(<i>N</i><sup>3</sup>) time. <h5>The Floyd-Warshall Algorithm</h5> <p> The Floyd-Warshall algorithm finds the length of the shortest paths between all pairs of vertices. It requires an adjacency matrix containing edge weights, the algorithm constructs optimal paths by piecing together optimal subpaths. <ul> <li> Note that the single edge paths might not be optimal and this is okay.</li> <li> Start with all single edge paths. The distance between two vertices is the cost of the edge between them or infinity if there is no such edge.</li> <li> For each pair of vertices <i>u</i> and <i>v</i>, see if there is a vertex <i>w</i> such that the path from <i>u</i> to <i>v</i> through <i>w</i> is shorter than the current known path from to <i>u</i> to <i>v</i>. If so, update it.</li> <li> Miraculously, if ordered properly, the process requires only one iteration. </li> <li> For more information on why this works, consult Chapter 26 of [Cormen, Leiserson, Rivest].</li> </ul> <p> Pseudocode: <br> <tt><font size='2'> <br> # dist(i,j) is "best" distance so far from vertex i to vertex j <br><br> # Start with all single edge paths.<br> For i = 1 to n do<br>     For j = 1 to n do<br>         dist(i,j) = weight(i,j) <br><br> For k = 1 to n do # k is the `intermediate' vertex<br>     For i = 1 to n do<br>         For j = 1 to n do<br>             if (dist(i,k) + dist(k,j) < dist(i,j)) then # shorter path?<br>                 dist(i,j) = dist(i,k) + dist(k,j)<br> </font></tt> <p> This algorithm runs in O(<i>V</i><sup>3</sup>) time. It requires the adjacency matrix form of the graph. <p> It's very easy to code and get right (only a few lines). <p> Even if the solution requires only the single source shortest path, this algorithm is recommended, provided the time and memory and are available (chances are, if the adjacency matrix fits in available memory, there is enough time). <h4>Problem Cues</h5> <p> If the problem wants an optimal path or the cost of a minimal route or journey, it is likely a shortest path problem. Even if a graph isn't obvious in a problem, if the problem wants the minimum cost of some process and there aren't many states, then it is usually easy to superimpose a graph on it. The big point here: shortest path = search for the minimal cost way of doing something. <h4> Extensions </h5> <p> If the graph is unweighted, the shortest path contains a minimal number of edges. A breadth first search (BFS) will solve the problem in this case, using a queue to visit nodes in order of their distance from the source. If there are many vertices but few edges, this runs much faster than Dijkstra's algorithm (see Amazing Barn in Sample Problems). <p> If negative weight edges are allowed, Dijkstra's algorithm breaks down. Fortunately, the Floyd-Warshall algorithm isn't affected so long as there are no negative cycles in the graph (if there is a negative cycle, it can be traversed arbitrarily many times to get ever `shorter' paths). So, graphs must be checked for them before executing a shortest path algorithm. <p> It is possible to add additional conditions to the definition of shortest path (for example, in the event of a tie, the path with fewer edges is shorter). So long as the distance function can be augmented along with the comparison function, the problem remains the same. In the example above, the distance function contains two values: weight and edge count. Both values would be compared if necessary. <h4> Sample Problems </h5> <h5> Graph diameter </h5> <p> Given: an undirected, unweighted, connected graph. Find two vertices which are the farthest apart. <p> Analysis: Find the length of shortest paths for all pairs and vertices, and calculate the maximum of these. <h5> Knight moves </h5> <p> Given: Two squares on an NxN chessboard. Determine the shortest sequence of knight moves from one square to the other. <p> Analysis: Let the chessboard be a graph with 64 vertices. Each vertex has at most 8 edges, representing squares 1 knight move away. <h5> Amazing Barn (abridged) [USACO Competition Round 1996] </h5> <p> Consider a very strange barn that consists of N stalls (N < 2500). Each stall has an ID number. From each stall you can reach 4 other stalls, but you can't necessarily come back the way you came. <p> Given the number of stalls and a formula for adjacent stalls, find any of the `most central' stalls. A stall is `most central' if it is among the stalls that yields the lowest average distance to other stalls using best paths. <p> Analysis: Compute all shortest paths from each vertex to determine its average distance. Any O(<i>N</i><sup>3</sup>) algorithm for computing all-pairs shortest paths would be prohibitively expensive here since N=2500. However, there are very few edges (4 per vertex), making a BFS with queue ideal. A BFS runs in O(E) time, so to compute shortest paths for all sources takes O(VE) time - about: <br> 2500 x 10,000 = 2.5 x 10<sup>6</sup> things, much more reasonable than 2500<sup>3</sup> = 1.56 x 10<sup>10</sup> <h5> Railroad Routing (abridged) [USACO Training Camp 1997, Contest 1] </h5> <p> Farmer John has decided to connect his dairy cows directly to the town pasteurizing plant by constructing his own personal railroad. Farmer John's land is laid out as a grid of one kilometer squares specified as row and column. <p> The normal cost for laying a kilometer of track is $100. Track that must gain or lose elevation between squares is charged a per-kilometer cost of $100 + $3 x meters_of_change_in_elevation. If the track's direction changes 45 degrees within a square, costs rise an extra $25; a 90 degree turn costs $40. All other turns are not allowed. <p> Given the topographic map, and the location of both John's farm and the plan, calculate the cost of the cheapest track layout. <p> Analysis: This is almost a standard shortest path problem, with grid squares as vertices and rails as edges, except that the direction a square is entered limits the ways you can exit that square. The problem: it is not possible to specify which edges exist in advance (since the path matters). <p> The solution: create eight vertices for each square, one for each direction you can enter that square. Now you can determine all of the edges in advance and solve the problem as a shortest path problem. </body>

 

 

 

 

0

 

USACO教程:Shortest Paths最短路径

2017-04-13 17:10:37

1

64

N

2

2

0

1283

USACO_2.4-1:The Tamworth Two两只塔姆沃斯牛

The Tamworth Two 两只塔姆沃斯牛 译 by Jure 修订 by ForEverLeeR BOI '98? - Richard Forster 两只牛逃跑到了森林里。农夫John开始用他的经验追捕这两头牛。你的任务是模拟他们的行为(牛和John)。 追击在10x10的平面网格内进行。一个格子可以是: 一个障碍物, 两头牛(它们总在一起), 或者 农民John. 两头牛和农民John可以在同一个格子内(当他们相遇时),但是他们都不能进入有障碍的格子。 一个格子可以是: . 空地 * 障碍物 C 两头牛 F 农民John 这里有一个地图的例子: *...*..... ......*... ...*...*.. .......... ...*.F.... *.....*... ...*...... ..C......* ...*.*.... .*.*...... 牛在地图里以固定的方式游荡。每分钟,它们可以向前移动或是转弯。如果前方无障碍且不会离开地图,它们会按照原来的方向前进一步。否则它们会用这一分钟顺时针转90度。 农民John深知牛的移动方法,他也这么移动。 每次(每分钟)农民John和两头牛的移动是同时的。如果他们在移动的时候穿过对方,但是没有在同一格相遇,我们不认为他们相遇了。当他们在某分钟末在某格子相遇,那么追捕结束。 读入十行表示农夫John,两头牛和所有障碍的位置的地图。每行都只包含10个字符,表示的含义和上面所说的相同,你可以确定地图中只有一个'F'和一个'C'.'F''C'一开始不会处于同一个格子中。 计算农夫John需要多少分钟来抓住他的牛,假设牛和农夫John一开始的行动方向都是正北(即上)。如果John和牛永远不会相遇,输出0 PROGRAM NAME: ttwo

1-10: 每行10个字符,表示如上文描述的地图。

输出一个数字,表示John需要多少时间才能抓住牛们。输出0,如果John无法抓住牛。

SAMPLE INPUT (file ttwo.in) *...*..... ......*... ...*...*.. .......... ...*.F.... *.....*... ...*...... ..C......* ...*.*.... .*.*......

SAMPLE OUTPUT (file ttwo.out) 49

0

 

USACO_2.4-1:The Tamworth Two两只塔姆沃斯牛

2017-04-13 17:10:37

1

64

N

0

2

0

1284

USACO_2.4-2:Overfencing穿越栅栏

Overfencing穿越栅栏 Kolstad and Schrijvers  by lyl 农夫John在外面的田野上搭建了一个巨大的用栅栏围成的迷宫。幸运的是,他在迷宫的边界上留出了两段栅栏作为迷宫的出口。更幸运的是,他所建造的迷宫是一个完美的迷宫:即你能从迷宫中的任意一点找到一条走出迷宫的路。给定迷宫的宽W(1<=W<=38)及长H(1<=H<=100) 2*H+1行,每行2*W+1的字符以下面给出的格式表示一个迷宫。然后计算从迷宫中最糟糕的那一个点走出迷宫所需的步数。(即使从这一点以最优的方式走向最靠近的出口,它仍然需要最多的步数)当然了,牛们只会水平或垂直地在XY轴上移动,他们从来不走对角线。每移动到一个新的方格算作一步(包括移出迷宫的那一步)这是一个W=5,H=3的迷宫: +-+-+-+-+-+ | | +-+ +-+ + + | | | | + +-+-+ + + | | | +-+ +-+-+-+ 如上图的例子,栅栏的柱子只出现在奇数行或奇数列。每个迷宫只有两个出口。 PROGRAM NAME: maze1

file maze1.in 第一行: WH(用空格隔开) 第二行至第2*H+2行: 每行2*W+1个字符表示迷宫

file maze1.out 输出一个单独的整数,表示能保证牛从迷宫中任意一点走出迷宫的最小步数。

5 3 +-+-+-+-+-+ | | +-+ +-+ + + | | | | + +-+-+ + + | | | +-+ +-+-+-+

9

0

 

USACO_2.4-2:Overfencing穿越栅栏

2017-04-13 17:10:37

1

64

N

2

3

0

1285

USACO_2.4-5:FractionsToDecimals分数化小数

写一个程序,输入一个形如N/D的分数(N是分子,D是分母),输出它的小数形式。如果小数有循环节的话,把循环节放在一对圆括号中。 例如, 1/3 =0.33333333 写成0.(3), 41/333 = 0.123123123... 写成0.(123), xxx.0 等表示整数。典型的转化例子: 1/3 = 0.(3) 22/5 = 4.4 1/7 = 0.(142857) 2/2 = 1.0 3/8 = 0.375 45/56 = 0.803(571428)

单独的一行包括被空格分开的 ND, 1 <= N,D <= 100000

按照上面规则计算出的小数表达式.如果结果长度大于76,每行输出76个字符.

(file fracdec.in) 45 56

(file fracdec.out) 0.803(571428)

0

 

USACO_2.4-4:Fractions to Decimals 分数化小数

2017-04-13 17:10:37

1

64

N

0

2

0

1286

【高精度】求n!的值

读入一个整数n1<=n<=100),输入n!结果。

10

3628800

10

3628800

0

 

高精度计算

2017-04-13 17:10:37

1

64

N

3

7

0

1287

【高精度】a*b

高精度乘法!

读入高精度a;(不超过200) 读入高精度b;(不超过200)

输出高精度a*b;

10 20

200

0

 

高精度计算

2017-04-13 17:10:37

1

64

N

5

7

0

1288

【高精度】a+b

输入两个整数,每个数的位数均不超过5000位,输出两个整数之和。

3 4

7

45 45

90

0

 

高精度加法

2017-04-13 17:10:37

1

64

N

7

18

0

1289

【高精度】a-b

输入两个高精度数据a,b,求a-b的差。

3 2

1

2 8

-6

0

 

高精度减法

2017-04-13 17:10:37

1

64

N

10

25

0

1290

二路归并排序

第一行读入n;第二行读入n个有序数据;(n<=10000) 第三行读入m;第四行读入m个有序数据;(m<=10000) 对以上共n+m个数据进行排序,并输出为一行!

 

 

7 1 3 7 13 17 21 77 9 3 5 6 7 30 40 50 60 90

1 3 3 5 6 7 7 13 17 21 30 40 50 60 77 90

0

 

 

2017-04-13 17:10:37

1

64

N

1

3

0

1291

使用二分查找做数据判断

读入一个数据规模n。(n<30000) 接下来读入n个有序数据集合。 读入一个数据m,判断m是否出现在前面所读入的n个有序数据中, 输出: 首先输出比较次数k, 接下来,共k行,每一行要求输出第几次比较的次数,以及比较对应的数。 如果找输入的数m不在前面所输入的n个有序数据中,则输出“no find!”

10 10 16 26 39 41 61 81 83 83 84 16

2 1 41 2 16

 

 

0

 

 

2017-04-13 17:10:37

1

64

N

3

3

0

1292

归并排序

二路归并思想!(贪心法策略) (注意算法运行时间!!!,不要超过1秒) 每一行,读入一个数据nn<=30000), 接下来读入n个数据,每个数据均为整型。 要求输出每一次归并排序操作过程中合并的数据段,有序输出!

10{n:表示将读入10个数据} 39 90 69 80 17 2 72 2 56 52{所读入的十个没有排序的数据}

1:39 90 2:39 69 90{前面2表示第二次归并,合面表示此次归并的数据,做有序输出} 3:17 80 4:17 39 69 80 90 5:2 72 6:2 2 72 7:52 56 8:2 2 52 56 72 9:2 2 17 39 52 56 69 72 80 90

 

 

0

 

 

2017-04-13 17:10:37

10

64

N

1

1

0

1293

循环比赛日程表

设有n个选手的循环比赛,其中n=2^m,要求每名选手要与其他n-1名选手都赛一次。每名选手每天比赛一次,循环赛共进行n-1天。要求每天没有选手轮空,以下是八名选手时的循环比赛表,表中第一行为八位选手的编号,下面七行依次是每位选手每天的对手。 1. 2 3 4 5 6 7 8 2. 1 4 3 6 5 8 7 3. 4 1 2 7 8 5 6 4. 3 2 1 8 7 6 5 5. 6 7 8 1 2 3 4 6. 5 8 7 2 1 4 3 7. 8 5 6 3 4 1 2 8. 7 6 5 4 3 2 1

读入一个整数m,其中(m<=100)

输入共2^m行,每一行对应一个运动员的比赛安排表。(每个数据的场宽为3)其中每行第一个数据为选手编号,后面外加一个“.”作为分格符。

3

1. 2 3 4 5 6 7 8 2. 1 4 3 6 5 8 7 3. 4 1 2 7 8 5 6 4. 3 2 1 8 7 6 5 5. 6 7 8 1 2 3 4 6. 5 8 7 2 1 4 3 7. 8 5 6 3 4 1 2 8. 7 6 5 4 3 2 1

0

 

 

2017-04-13 17:10:37

1

64

N

1

1

0

1294

表达式去括号

用键盘输入一个含有括号的四则运算表达式,表达式中可能含有多余的括号,编程整理表达式,去掉所有多余的括号,使得原表达式中所有变量和运算符相对位置保持不变,并保持与原表达式等价。

输入表达式:a+(b+c)

输出表达式:a+b+c

样例1: (a*b)+c/d 样例2 a+b/(c-d)

样例1: a*b+c/d 样例2a+b/(c-d)

0

 

 

2017-04-13 17:10:37

1

64

N

0

1

0

1295

【树图】单源点最短路

给定一个带权(无负权)的有向图,求顶点1到其外他各顶点的最短路。 《Dijkstra算法》思想: Dijkstra算法是解决单源点最短路径问题的贪心算法。其基本思想是设置顶点集合S,首先将源点加入该集合,然后依据源点到其他顶点的路径长度,选择路径长度最小的顶点加入集合,根据所加入顶点更新源点到其他顶点的路径长度,然后再选取最小边的顶点,依次来做,直到求解出所有顶点的路径长度。 给定带权有向图G=(VE),其中每条边的权是非负实数,另外,再给定 V 中的一个顶点,我们称之为源点。再计算从源点到其他顶点的最短路径长度。这个问题称为图论单源点最短路问题。

 

 

5 0 4 29 4 0 2 0 0 0 3 0 6 0 0 4 0 0 0 0 6 0 0 4 0 0

4 11 4 7

0

 

数据结构与算法设计 P69

2017-04-13 17:10:37

1

64

N

3

5

0

1296

【树图】最优乘车(NOI94

H城是一个旅游胜地,每年都有成千上万的人前来观光。为方便游客,巴士公司在各个旅游景点及宾馆、饭店等地都设置了巴士站并开通了一些单程巴士线路。每条章程巴士线路从某个巴士站出发,依次途经若干个巴士站,最终到达弱点巴士站。一名旅客最近到H城旅游,他很想去S公园游玩,但如果从他所在的饭店没有一路巴士可以直接到达S公园,则他可能要先乘某一路巴士从几站,再下来换乘同一站台的另一巴士,这样换乘几次后到达S公园。现在用整数12……NH城的所有巴士站编号,约定这名旅客所在饭店的巴士站编号为1……S,公园巴士站的编号为N。 编写程序,帮助这名旅客寻找一个最优乘车方案,使他在从饭店乘车到S公园的过程中换车的次数最少。

文件的第一行有两个数字MN1<= M <= 1001 < N <= 500),表示开通了M条单程巴士线路,总共有N个车站。 从第二行到第M行依次给出了第1条到第M条巴士线路的信息。其中第i+1行给出的是第i条巴士线路的信息,从左至右按运行顺序依次给出了该线路上的所有站号,相邻两个站号之间用一个空格隔开。

文件只有一行。如果无法乘巴士从饭店到达S公园,则输出“NO”,否则输出你的程序所找到的最少换车次数,换车次数为0表示不需换车即可到达。

3 7 6 7 4 7 3 6 2 1 3 5

2

0

 

数据结构与算法设计 P73

2017-04-13 17:10:37

1

64

N

0

2

0

1297

【树图】构建互联网(prim算法)

农民约翰被选为他们镇的镇长! 他其中一个竞选承诺就是在镇上建立起互联网,并连接到所有的农场。当然,他需要你的帮助。 约翰已经给他的农场安排了一条高速的网络线路,他想把这条线路共享给其他农场。为了用最小的消费,他想铺设最短的光纤去连接所有的农场。 你将得到一份各农场之间连接费用的列表,你必须找出能连接所有农场并所用光纤最短的方案。

该题含有多组测试数据。 第一行为M表示有M组测试数据。 每组数据第一行为农场的个数,N3<=N<=100)。 接下去为一个N*N的矩阵,表示每个农场之间的距离。(农场之间的距离小于100000)

每组数据只有一个输出,其中包含连接到每个农场的光纤的最小长度。

1 4 0 4 9 21 4 0 8 17 9 8 0 16 21 17 16 0

28

0

 

usaco & 数据结构与算法设计 P89

2017-04-13 17:10:37

1

64

N

2

3

0

1298

【树图】最优布线问题(kruskal算法)

学校有n台计算机,为了方便数据传输,现要将它们用数据线连接起来。两台计算机被连接是指它们时间有数据线连接。由于计算机所处的位置不同,因此不同的两台计算机的连接费用往往是不同的。 当然,如果将任意两台计算机都用数据线连接,费用将是相当庞大的。为了节省费用,我们采用数据的间接传输手段,即一台计算机可以间接的通过若干台计算机(作为中转)来实现与另一台计算机的连接。 现在由你在负责连接这些计算机,你的任务是使任意两台计算机都连通(不管是直接的或间接的)。

从文本文件wire.in中读入数据。 第一行一个整数n2<=n<=100),表示计算机的数目。 此后的n行,每行n个整数。第xy列的整数表示直接连接第x台计算机和第y台计算机的费用。

一个整数,表示最小的连接费用。

3 0 1 2 1 0 1 2 1 0

2

0

(连接1223,费用为2

 

2017-11-07 13:54:26

1

64

N

44

121

0

1299

金猪大家庭1

金猪大家庭主要由母猪构成的,小母猪第二年就可以生2只小母猪和2只小公猪,第三年开始每年可以生4只小母猪和4只小公猪;小公猪在第二年就要被赶出大家庭;猪的寿命只有六年。 目前,一个新的金猪大家庭正在形成:一只小母猪自立门户,创建自己的金猪大家庭。

只有一行且只有一个正整数:n (1<=n<=35) 。表示n年后。

输出只有一行且只有一个正整数m。(表示n年后金猪大家庭所有成员的数量)

2

5

0

关键数据的处理:n=35,希望有人能给出测试数据!(我没有放这个测试数据)

 

2017-04-13 17:10:37

1

64

N

1

2

0

1300

污水处理点

SH市的底下水管道是呈网络状铺设的。在一些地方,有小型污水处理点,编号从1N。这些污水处理点负责将经过该点的所有管道中的水处理和转向。 小明知道,管道是双向的,并且每个污水处理点处理的水都可以流到任意的另一个污水处理点(可能要通过其他污水处理点)。 然而,管道是有长度大小的,水从一个污水处理点流到另一个污水处理点总是按照最短路径进行流动的。   小明计算出:任意两个处理点之间的最短路径管道长度和为D(i,j)。 由于地下污水处理点过多,导致水流的大混乱。小明希望能够拆除一些地下污水处理点。小明是这样定义一个可拆除的污水处理点的:  对于污水处理点u,在其他点都不拆除的情况下,u满足: 1) 拆除u后,图仍然保持连通性--任意两个污水处理点可以互相到达; 2) 拆除u后,与u相连的管道也被拆除。此时,图中剩下的任意两个污水处理点之间的最短路径管道长度和为D'(i,j)。对于任意的(i,j) i≠u,j≠u),都要满足D'(i,j) = D(i,j),即最短路径长度不变。 在满足上述两个条件的情况下,污水处理点u是可拆除点。   小明希望你能帮他统计出SH市地下所有可以拆除的污水处理点。

输入文件第一行有两个整数NM N为点数,M为管道数目(3≤N≤502≤M≤1250)。 以下M行,每行有三个数pqw1≤p≤q≤N1≤w≤100),表示污水处理点p和污水处理点q之间有一条长度为w的管道。

输出文件第一行为可以拆除的污水处理点的个数K。 以下K行,按编号从小到大顺序,依次输出每个可拆除的污水处理点的编号。

4 4 1 2 1 2 3 1 3 4 100 1 4 1

2 3 4

0

 

 

2017-04-13 17:10:37

1

64

N

2

2

0

1301

产生数

给出一个整数 nn<10^30) 和 k 个变换规则(k<=15)。   规则:    一位数可变换成另一个一位数:    规则的右部不能为零。   例如:n=234。有规则(k2):     2> 5     3> 6   上面的整数 234 经过变换后可能产生出的整数为(包括原数):    234    534    264    564   共 4 种不同的产生数 问题求解:   给出一个整数 n  k 个规则。   经过任意次的变换(0次或多次),能产生出多少个不同整数。   仅要求输出个数。

输入格式为:   n k   x1 y1   x2 y2   ... ...   xk yk

输出格式为:一个整数(满足条件的个数)。

234 2 2 5 3 6

4

0

 

 

2017-04-14 12:58:54

1

64

N

3

3

0

1302

巴比伦塔

巴比伦人有n种砖块,每种数量不限。每一种砖块i是一个长方体,有三个维度(Xi,Yi,Zi)。一个砖块可被任意放置,三个维度中的任两个可作为底座,第三个作为高。巴比伦人要用堆砖块的方法建造尽可能高的塔。问题是,建塔时,一个砖块仅当它的底座的长宽比另一个砖块的都小时,它才能堆在另一个砖块上。这意味着,两个底座相同的砖块不能堆在一起。 你的任务是要确定用所给的砖块,巴比伦人最高能堆的塔的高度。

输入文件有一组或多组测试数据。每组测试的第一行有一个整数N ,表示有N种不同种类的砖块,N 最大值为30。以下N行每行3个整数,表示一种砖块的三个维度X,Y,Z N = 0时输入结束。

对每一组测试,输出该组测试的序号(从1开始)和最高可能高度,格式为: Case C: maxinum height = h 其中C为测试序号,h 为最高高度。

1 10 20 30 2 6 8 10 5 5 5 7 1 1 1 2 2 2 3 3 3 4 4 4 5 5 5 6 6 6 7 7 7 5 31 41 59 26 53 58 97 93 23 84 62 64 33 83 27 0

Case 1: maxinum height = 40 Case 2: maxinum height = 21 Case 3: maxinum height = 28 Case 4: maxinum height = 342

0

 

 

2017-04-14 12:58:54

1

64

N

0

2

0

1303

交换比率问题

用纸币来支付商品和服务的费用可以使生活方便,可是人们有时希望能够直接交换物品而不使用钱币来作媒介。为了确保一致的价格,商人们制订了一个关于商品的交换比率。我们用正整数MN来表示商品AB的交换比率,并说M个商品A等价于N个商品B。举例来说,2个火炉应该等价于3个冰箱(从数学的角度来说,1个火炉等价于1.5个冰箱,但是要拿出半个冰箱不是件容易的事,交换比率总是那些有实际意义的整数)。 请写一个程序,对于给出的交换比率表,计算出任意两件商品的交换比率。

输入文件中的第一行为一个整数,表示测试数据的组数。每组数据中均要包含至少一个命令,结尾用一个“$”号来表示。 每个命令独占一行,命令可以是一个断言或一个疑问。如果是断言,则以感叹号开头,并按如下格式: ! m itema = n itemb itemaitemb应是具体的商品名称,mn都是不大于100的正整数。这个命令断言了mitema等价于nitemb。如果命令是一个疑问,则以问号开头,并按如下格式: ? itema = itemb 表示询问itemaitemb之间的交换比率,itemaitemb是在上文的断言中曾出现过的具体的商品名称(itemaitemb不一定要在同一断言中出现)。 注意: 商品名字只能用不多于20个小写字母来表示。 商品的名字用单数表示(不要用复数形式)。 最多有60种不同的商品。 对于每一对不同的商品,最多只能有一个断言。

对于每个疑问,根据所有的有关的断言,输出itemaitemb之间的交换比率。交换比率必须是整数形式而且应该尽可能的小。如果不能找到相应的交换比率,用问号代替整数来表示。请严格按照下面例子输出。 可能有永假的断言,举例来说, "2 pig = 1 cow", "2 cow = 1 horse", and "2 horse = 3 pig" 是永假,不成立。若在一组数据中发现有永假的断言,则不作任何处理,只需输出一个组号+“”+“ERROR。 断言中的比率不一定要是最小的,但是输出的比率一定要是最小的形式。虽然断言中不能有大于100的数字,但疑问中可以出现比100大的数字。疑问的答案化成最小后输出。

1 ! 6 shirt = 15 sock ! 47 underwear = 9 pant ? sock = shirt ? shirt = pant ! 2 sock = 1 underwear ? pant = shirt $

5 sock = 2 shirt ? shirt = ? pant 45 pant = 188 shirt

0

 

 

2017-04-14 12:58:54

1

64

N

0

1

0

1304

降 水

有这样一块土地,它可以被划分成N×M个正方形小块,每块面积是一平方米,第i行第j列的小块可以表示成P(i,j)。这块土地高低不平,每一小块地P(i,j)都有自己的高度H(i,j)(单位是米)。 一场倾盆大雨后,这块地由于地势高低不同,许多低洼地方都积存了不少降水。假如你已经知道这块土地的详细信息,你能求出它最多能积存多少立方米的降水么?

输入文件第一行有两个数,NM1<=N, M <=100),表示土地的规模是N×M平方米。 以下有N行,每行有M个整数,表示每块地的高低(每个整数在[1,10000]内,以米为单位)。

输出文件只有一行,一个数,表示土地中最多能积存多少立方米的水。

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1304.GIF > 3 6 3 3 4 4 4 2 3 1 3 2 1 4 7 3 1 6 4 1

5

0

 

 

2017-04-14 12:58:54

1

64

N

0

2

0

1305

勇探地洞

我们发现在火星的南极有一个地洞。现在航天员就站在地洞口。在地洞的旁边有一块铝板,上面画着地洞的地 图。这个地洞是由N个房间和连接它们的M条通道组成的。由于N个房间中没有4个房间共面,所以通道并不相交 。两个房间之间可能有多个通道,通道都是双向的。洞口算做1号房间,而在N号房间里藏有火星人的全部科技 和历史。航天员乘坐的是WORM2030型洞穴探测器,这种探测器速度飞快,转向灵活。可以以速度V在通道中行 驶而在房间里的转向不需要时间,它还配有一枚火箭,在必要的时候点燃,可以将速度提高到MVMV>V),但 是这个速度只能在一段通道内保持,一旦到了别的通道就会恢复原来的速度V。现在航天员要用最短的时间到 达N号房间,你的任务就是帮他设计一条路线。

 

 

 

 

0

 

 

2017-04-14 12:58:54

1

64

N

1

2

0

1306

求图中任意两点间的距离

读入一个图,N为图的阶, 接下来读入N*N个数据,表示图中各个结点间对应的权值; 读入一个整数m,表示要求求出m对结点间的最短路径。 如果图中某对结点之间无路可走,则输出:"no find road!"

6{n为图的阶} 0 7 6 2 0 0{读入图的相关信息:带权邻接矩阵} 7 0 0 3 4 0 6 0 0 5 0 3 2 3 5 0 5 4 0 4 0 5 0 6 0 0 3 4 6 0 2{读入要求的点对数目:m} 1 5 3 6

7{结点:15之间的最短路径为:7} 3{结点36之间的最短路径为:3}

6 0 7 6 2 0 0 7 0 0 3 4 0 6 0 0 5 0 3 2 3 5 0 5 4 0 4 0 5 0 6 0 0 3 4 6 0 2 1 5 3 6

7 3

0

 

 

2017-04-14 12:58:54

1

64

N

1

1

0

1307

【串】国家名排序

对给定的10个国家名,按其字母的顺序输出。 输入:数据有10行,每行一个国家的名字 输出:数据为排好序的国家名字,每行一个国家名字

数据有10行,每行一个国家的名字

数据为排好序的国家名字,每行一个国家名字

 

 

0

了解一下字符串的比较!

 

2017-04-14 12:58:54

1

64

N

3

3

0

1308

【串】校对日期

校对输入日期(以标准英语日期,//)的正确性,若输入正确则以年.月.日的方式输出。 (正确日期样例:10/3/200310/12/2006)

一个日期(月//年)

正确的日期输入将其转化为..的方式输出,错误的输入则输出“input error!”

10/3/2003

2003.10.3

0

 

 

2017-04-14 12:58:54

1

64

N

1

3

0

1309

【串】回文数判断

找出字符串中的所有回文数。

读入任意一个字符串

按字符串长度从小到大输出所有可行的回文数 (相同长度按其大小,比较后从小到大输出。字符串之间用“,”号间隔开)

122122133

1,2,3,22,33,212,1221,22122,1221221

0

 

 

2017-04-14 12:58:54

1

64

N

0

1

0

1310

【串】任意进制转换

将一个M进制的数转换为N进制的数。

输入数据共3行: 第一行:当前进制M,如8; 第二行:要转换的M进制的数,如:154; 第三行:要转换成的N进制,如:16

输出:转换成N进制后的结果,如:6C

8 154 16

6C

0

 

 

2017-04-14 12:58:54

1

64

N

1

3

0

1311

【串】宴会排座问题

在一次宴会上,有来自八个不同国家的宾客被安排在同一张圆桌就坐。 A是中国人,会讲英语;B是意大利人,他能讲西班牙语;C是英国人,会讲法语;D是日本人,能讲汉语;E是法国人,会讲德语;F是俄国人,懂意大利语;G是西班牙人,能讲日语;最后一个是德国人,懂俄语。 编程序安排他们的座位,使他们在各自的座位上能方便地跟两旁的客人交谈。

 

 

 

 

0

 

 

2017-04-14 12:58:54

1

64

N

3

3

0

1312

【串】谁拿了最多奖学金(NOIP05T-1)

某校的惯例是在每学期的期末考试之后发放奖学金。发放的奖学金共有五种,获取的条件各自不同: 1)院士奖学金,每人8000元,期末平均成绩高于80分(>80),并且在本学期内发表1篇或1篇以上论文的学生均可获得; 2)五四奖学金,每人4000元,期末平均成绩高于85分(>85),并且班级评议成绩高于80分(>80)的学生均可获得; 3)成绩优秀奖,每人2000元,期末平均成绩高于90分(>90)的学生均可获得; 4)西部奖学金,每人1000元,期末平均成绩高于85分(>85)的西部省份学生均可获得; 5)班级贡献奖,每人850元,班级评议成绩高于80分(>80)的学生干部均可获得; 只要符合条件就可以得奖,每项奖学金的获奖人数没有限制,每名学生也可以同时获得多项奖学金。例如姚林的期末平均成绩是87分,班级评议成绩82分,同时他还是一位学生干部,那么他可以同时获得五四奖学金和班级贡献奖,奖金总数是4850元。 现在给出若干学生的相关数据,请计算哪些同学获得的奖金总数最高(假设总有同学能满足获得奖学金的条件)。

输入文件scholar.in。 第一行是一个整数N1≤N≤100),表示学生的总数。 接下来的N行每行是一位学生的数据,从左向右依次是姓名,期末平均成绩,班级评议成绩,是否是学生干部,是否是西部省份学生,以及发表的论文数。 姓名是由大小写英文字母组成的长度不超过20的字符串(不含空格); 期末平均成绩和班级评议成绩都是0100之间的整数(包括0100); 是否是学生干部和是否是西部省份学生分别用一个字符表示,Y表示是,N表示不是; 发表的论文数是010的整数(包括010)。 每两个相邻数据项之间用一个空格分隔。

输出文件scholar.out包括三行, 第一行是获得最多奖金的学生的姓名, 第二行是这名学生获得的奖金总数。如果有两位或两位以上的学生获得的奖金最多,输出他们之中在输入文件中出现最早的学生的姓名。 第三行是这N个学生获得的奖学金的总数。

4 YaoLin 87 82 Y N 0 ChenRuiyi 88 78 N Y 1 LiXin 92 88 N N 0 ZhangQin 83 87 Y N 1

ChenRuiyi 9000 28700

0

 

 

2017-04-14 12:58:54

1

64

N

2

3

0

1313

【串】编加法器

做一个加法器。完成30000以内的加法,两个加数间用“+”连接,可以连加,回车表示式子输入完成;“#”表示结束运算,退出加法器。

输入样例:389+7+9031#

输出样例:9427

389+7+9031#

9427

0

 

 

2017-04-14 12:58:54

1

64

N

2

3

0

1314

【串.高精度】回文数

若一个数(首位不为零)从左到右读与从右到左读都是一样,我们就将其称之为回文数。 例如:给定一个10进制数56,将5665(即把56从右向左读),得到121是一个回文数。 又如,对于10进制数87:     STEP187+78=165 STEP2165+561=726     STEP3726+627=1353 STEP41353+3531=4884   在这里的一步是指进行了一次N进制的加法,上例最少用了4步得到回文数4884。    写一个程序,给定一个N2<=N<=10N=16)进制数M,求最少经过几步可以得到回文数。 如果在30步以内(包含30步)不可能得到回文数,则输出“Impossible!”

输入样例: N=9 M=87

输出样例: STEP=6

N=9 M=87

STEP=6

0

N进制加法即逢N进一

 

2017-04-14 12:58:54

1

64

N

0

2

0

1315

【串】数码排序

设有n个正整数,将他们连接成一排,组成一个最大的多位整数, 例如:当n=3时,3个整数为13312343,连成的最大整数为:34331213 又如:当n=4时,4个整数为7134246,连接成的最大整数为7424613

输入共n+1行: 第一行一个整数n; 接下来n行,每行一个整数

输出一行,连接成的多位数

样例1 3 13 312 343 样例2 4 7 13 4 246

样例1 34331213 样例2 7424613

0

 

 

2017-04-14 12:58:54

1

64

N

0

2

0

1316

栈的思考

对于栈,我们之前已有所了解,它的存储与实现可以抽象出为:线性表+表头操作;如果有n个元素,它们入栈的顺序是固定的为:1、2、3……n,问其出栈顺序有多少种情况? 如:n=3,入栈顺序为:1、2、3   则其出栈顺序为:1 2 3;1 3 2; 2 1 3;2 3 1;3 1 2; 共5种。

3

5

4

14

0

 

 

2017-04-14 12:58:54

1

64

N

1

1

0

1317

USACO_2.4-3:Cow Tours牛的旅行

农民John的农场里有很多牧区。有的路径连接一些特定的牧区。一片所有连通的牧区称为一个牧场。但是就目前而言,你能看到至少有两个牧区通过任何路径都不连通。这样,农民John就有多个牧场了。 John想在农场里添加一条路径(注意,恰好一条)。对这条路径有以下限制: 一个牧场的直径就是牧场中最远的两个牧区的距离(本题中所提到的所有距离指的都是最短的距离)。考虑如下的有5个牧区的牧场,牧区用“*”表示,路径用直线表示。每一个牧区都有自己的坐标: 15,15 20,15 D E *-------* | _/| | _/ | | _/ | |/ | *--------*-------* A B C 10,10 15,10 20,10 这个牧场的直径大约是12.07106, 最远的两个牧区是AE,它们之间的最短路径是A-B-E。 这里是另一个牧场: *F 30,15 / _/ _/ / *------* G H 25,10 30,10 这两个牧场都在John的农场上。John将会在两个牧场中各选一个牧区,然后用一条路径连起来,使得连通后这个新的更大的牧场有最小的直径。 注意,如果两条路径中途相交,我们不认为它们是连通的。只有两条路径在同一个牧区相交,我们才认为它们是连通的。 输入文件包括牧区、它们各自的坐标,还有一个如下的对称邻接矩阵:   A B C D E F G H A 0 1 0 0 0 0 0 0 B 1 0 1 1 1 0 0 0 C 0 1 0 0 1 0 0 0 D 0 1 0 0 1 0 0 0 E 0 1 1 1 0 0 0 0 F 0 0 0 0 0 0 1 0 G 0 0 0 0 0 1 0 1 H 0 0 0 0 0 0 1 0 输入文件至少包括两个不连通的牧区。 请编程找出一条连接两个不同牧场的路径,使得连上这条路径后,这个更大的新牧场有最小的直径。

1: 一个整数N (1 <= N <= 150), 表示牧区数 第2N+1: 每行两个整数X,Y (0 <= X ,Y<= 100000), 表示N个牧区的坐标。注意每个 牧区的坐标都是不一样的。 第N+2行到第2*N+1: 每行包括N个数字(01) 表示如上文描述的对称邻接矩阵。

只有一行,包括一个实数,表示所求直径。数字保留六位小数。

8 10 10 15 10 20 10 15 15 20 15 30 15 25 10 30 10 01000000 10111000 01001000 01001000 01110000 00000010 00000101 00000010

22.071068

0

 

 

2017-04-14 12:58:54

1

64

N

2

2

0

1318

USACO_2.4-4:Bessie Come Home回家

现在是晚餐时间,而母牛们在外面分散的牧场中。农民约翰按响了电铃,所以她们开始向谷仓走去。你的工作是要指出哪只母牛会最先到达谷仓(在给出的测试数据中,总会有且只有一只速度最快的母牛)。在挤奶的时候(晚餐前),每只母牛都在她自己的牧场上,一些牧场上可能没有母牛。每个牧场由一条条道路和一个或多个牧场连接(可能包括自己)。有时,两个牧场(可能是自我相同的)之间会有超过一条道路相连。至少有一个牧场和谷仓之间有道路连接。因此,所有的母牛最后都能到达谷仓,并且母牛总是走最短的路径。当然,母牛能向着任意一方向前进,并且她们以相同的速度前进。牧场被标记为'a'..'z''A'..'Y',在用大写字母表示的牧场中有一只母牛,小写字母中则没有。谷仓的标记是'Z',注意没有母牛在谷仓中。 注意'm''M'不是一个牧场

 1 : 整数 P(1<= P<=10000),表示连接牧场(谷仓)的道路的数目。 第 2 ..P+1: 用空格分开的两个字母和一个整数: 被道路连接牧场的标记和道路的长度(1<=长度<=1000)

单独的一行包含二个项目: 最先到达谷仓的母牛所在的牧场的标记,和这只母牛走过的路径的长度。

5 A d 6 B d 3 C e 9 d Z 8 e Z 3

B 11

0

 

 

2017-04-14 12:58:54

1

64

N

3

3

0

1319

USACO_3.1教程:最小生成树 (MST)

最小生成树 (MST)  by Lucky Crazy & Felicia Crazy 例题:最短网络 [Russ Cox, Winter 1999 USACO Open] 农民约翰被选为他们镇的镇长!他其中一个竞选承诺就是在镇上建立起互联网,并连接到所有的农场。当然,他需要你的帮助。 约翰已经给他的农场安排了一条高速的网络线路,他想把这条线路共享给其他农场。为了用最小的消费,他想铺设最短的光纤去连接所有的农场。 你将得到一份各农场之间连接费用的列表,你必须找出能连接所有农场并所用光纤最短的方案。 每两个农场间的距离不会超过100000 数学模型: 给出: 一幅连通的有权无向图。   一棵生成树的图是一张无向的连通图(也就是图中任意一对节点都是连通的). 而一棵最小生成树是一棵权和最小的生成树(即树所有的权值和最小). 利用 Prim 算法建造最小生成树: 给出: 所有节点和权值的列表。 利用贪心算法建造最小生成树,即在每次都将已有的生成树相连的一个权值最小的节点连入树中。 从某一个节点开始生成。 确定所有不在树中结点连接到树中所需的最小权值(如下例中的distance),并记录下与之相连的结点(如下例中的source)。 如果有结点无法连入树中,那么假设它的权值为无穷大 (比图中所有的权值都大). 在每一步中,找出一个和生成树相连的权值最小的节点(即在distance栏中)并且用一条边将它连入树中。 (由于最小生成树的性质,它必定是不含圈的。否则断开这个圈仍然可以保证每个节点都在树中——译者) 如果你想知道详细的分析或该算法的正确性证明,请参考《Cormen, Leiserson, Rivest》的第24章。 伪代码: # distance(j) is distance from tree to node j # source(j) is which node of so-far connected MST # is closest to node j 1 For all nodes i 2 distance(i) = infinity # no connections 3 intree(i) = False # no nodes in tree 4 source(i) = nil 5 treesize = 1 # add node 1 to tree 6 treecost = 0 7 intree(1) = True 8 For all neighbors j of node 1 # update distances 9 distance(j) = weight(1,j) 10 source(j) = 1 11 while (treesize < graphsize) 12 find node with minimum distance to tree; call it node i 13 assert (distance(i) != infinity, "Graph Is Not Connected") # add edge source(i),i to MST 14 treesize = treesize + 1 15 treecost = treecost + distance(i) 16 intree(i) = True # mark node i as in tree # update distance after node i added 17 for all neighbors j of node i 18 if (distance(j) > weight(i,j)) 19 distance(j) = weight(i,j) 20 source(j) = i 该算法的时间复杂度为 O(N2)。使用堆可以得到 O(N log N)的复杂度。 图例: 考虑下图的权,边情况: 目标:生成最小生成树。 该算法将在1)节点开始,它与节点2),6),3)相连,权值情况如下: Node distance intree source 1 infinity True nil 2 30 False 1 3 20 False 1 6 25 False 1 已知不存在权为无穷大的情况。(intree=False & source=nil) 可连接的最小权为20, 所以节点3)被连入树中: Node distance intree source 1 infinity True nil 2 9 False 3 3 20 True 1 6 25 False 1 7 7 False 3 注意:节点3)现在已经在树中了,节点2)的权已经从20变成的9,且source也变成的3。 可连接的最小权为7, 所以节点3)和7)被连接: Node distance intree source 1 infinity True nil 2 9 False 3 3 20 True 1 6 10 False 7 7 7 True 3 可连接的最小权为节点2)的9。 连接节点3)2): Node distance intree source 1 infinity True nil 2 9 True 3 3 20 True 1 4 21 False 2 5 9 False 2 6 10 False 7 7 7 True 3 连接节点2)和5): Node distance intree source 1 infinity True nil 2 9 True 3 3 20 True 1 4 8 False 5 5 9 True 2 6 10 False 7 7 7 True 3 8 12 False 5 下一步连接节点5) 4: Node distance intree source 1 infinity True nil 2 9 True 3 3 20 True 1 4 8 True 5 5 9 True 2 6 10 False 7 7 7 True 3 8 12 False 5 连接节点6)和7: Node distance intree source 1 infinity True nil 2 9 True 3 3 20 True 1 4 8 True 5 5 9 True 2 6 10 True 7 7 7 True 3 8 11 False 6 最后,连接节点6)和8): Node distance intree source 1 infinity True nil 2 9 True 3 3 20 True 1 4 8 True 5 5 9 True 2 6 10 True 7 7 7 True 3 8 11 True 6 最小生成树完成。 注意: 必须知道某些情况下某些结点无法连入树中,应避免重复计算这些结点。(即 intree=False & source=nil,在例中没有该情况)。 题型提示: 如果某些问题需要一张最优的连通图,并且需要用以一个最小的花费来连接该系统或该系统的任意两个部分,这样的问题就极类似最小生成树问题。 拓展: 如果你的生成树有任何约束条件的话(任意两个结点可能离得非常远,或者平均距离必须最小),这个算法就玩完了,而且让程序适应这样的约束条件非常困难。 显而易见,任意两个结点之间不能有多边(你就留下权值最小的边,忽略其余的边)。 Prim 算法无法扩展到有向图(如果你想要的是强连通图的话)。 例题: 包裹寄送 给出:一些城市的位置,和轮船公司连接每对城市的航线的花费。找出使得一个包裹能够从任意一座城市送到任意的另外一座城市的花费最小。 高速公路建设 当然,为了经济效益,他们想要花最少的钱来做这件事。高速公路的花费正比于它的长度。给出 L.S. 州的所有城市的 x,y 坐标,设计使得所有城市互相连通的最便宜的建造方案。 Bovile 电话(已删节) [USACO Training Camp 1998, Contest 2] 给出:一些奶牛和田野中的干草堆(奶牛和干草堆在一起),连接任意的位置需要一定的花费。只用干草堆和奶牛,计算哪些干草堆应该包含在干草堆网络中,并且使总花费最小。 分析:对于每一组可能的干草堆(也就是,共有 2 n 组),计算这组干草堆和奶牛的最小生成树。计算最小生成树的组合,使得花费最小。

 

 

 

 

0

 

 

2017-04-14 12:58:54

1

64

N

2

2

0

1320

USACO_3.1.1Agri-Net最短网络

农民约翰被选为他们镇的镇长!他其中一个竞选承诺就是在镇上建立起互联网,并连接到所有的农场。当然,他需要你的帮助。约翰已经给他的农场安排了一条高速的网络线路,他想把这条线路共享给其他农场。为了用最小的消费,他想铺设最短的光纤去连接所有的农场。你将得到一份各农场之间连接费用的列表,你必须找出能连接所有农场并所用光纤最短的方案。每两个农场间的距离不会超过100000

第一行: 农场的个数,N3<=N<=100)。 第二行..结尾: 后来的行包含了一个N*N的矩阵,表示每个农场之间的距离。理论上,他们是N行,每行由N个用空格分隔的数组成,实际上,他们限制在80个字符,因此,某些行会紧接着另一些行。当然,对角线将会是0,因为不会有线路从第i个农场到它本身。

只有一个输出,其中包含连接到每个农场的光纤的最小长度。

4 0 4 9 21 4 0 8 17 9 8 0 16 21 17 16 0

28

0

 

 

2017-04-14 12:58:54

1

64

N

10

11

0

1321

USACO_3.1.2Score Inflation总分

学生在我们USACO的竞赛中的得分越多我们越高兴。 我们试着设计我们的竞赛以便人们能尽可能的多得分,这需要你的帮助。 我们可以从几个种类中选取竞赛的题目,这里的一个"种类"是指一个竞赛题目的集合,解决集合中的题目需要相同多的时间并且能得到相同的分数。你的任务是写一个程序来告诉USACO的职员,应该从每一个种类中选取多少题目,使得解决题目的总耗时在竞赛规定的时间里并且总分最大。输入包括竞赛的时间,M(1 <= M <= 10,000)(不要担心,你要到了训练营中才会有长时间的比赛)N,"种类"的数目1 <= N <= 10,000。后面的每一行将包括两个整数来描述一个"种类": 第一个整数说明解决这种题目能得的分数(1 <= points <= 10000),第二整数说明解决这种题目所需的时间(1 <= minutes <= 10000)。你的程序应该确定我们应该从每个"种类"中选多少道题目使得能在竞赛的时间中得到最大的分数。 来自任意的"种类"的题目数目可能任何非负数(0或更多)。 计算可能得到的最大分数。

 1 : M, N--竞赛的时间和题目"种类"的数目。 第 2-N+1 : 两个整数:每个"种类"题目的分数和耗时。

单独的一行包括那个在给定的限制里可能得到的最大的分数。

300 4 100 60 250 120 120 100 35 20

605 {从第2"种类"中选两题第4"种类"中选三题}

0

 

 

2017-04-14 12:58:54

1

64

N

0

3

0

1322

USACO_3.1.3Humble Numbers丑数

对于一给定的素数集合 S = {p1, p2, ..., pK}, 来考虑正整数集合中哪些数的质因数全部属于S。这个正整数集合包括,p1, p1p2, p1p1,  p1p2p3 (还有其它)。这是个对于一个输入的S集合的丑数集合。 注意:我们不认为1 是一个丑数。 你的工作是对于输入的集合S去寻找集合中的第N个丑数。longint(signed 32-bit)对于程序是足够的。

 1 : 二个被空格分开的整数:K  N  1<= K<=100  1<= N<=100,000.  2 : K 个被空格分开的整数:集合S的元素

单独的一行,写上对于输入的S的第N个丑数。

4 19 2 3 5 7

27

0

 

 

2017-04-14 12:58:54

1

64

N

4

4

0

1323

USACO_3.1.4Shaping Regions形成的区域

N个不同的颜色的不透明的长方形(1 <= N <= 1000)被放置在一张宽为A长为B的白纸上。这些长方形被放置时,保证了它们的边与白纸的边缘平行。所有的长方形都放置在白纸内,所以我们会看到不同形状的各种颜色。坐标系统的原点(0,0)设在这张白纸的左下角,而坐标轴则平行于边缘。

按顺序输入放置长方形的方法。第一行输入的是那个放在底的长方形(即白纸)。 第 1 : A  B  N, 由空格分开 (1 <=A, B<=10,000)  2 N+1: 为五个整数 llx, lly, urx, ury, color 这是一个长方形的左下角坐标,右上角坐标和颜色。 颜色 1和底部白纸的颜色相同。 (1 <= color <= 2500)

输出文件应该包含一个所有能被看到颜色连同该颜色的总面积的清单( 即使颜色的区域不是连续的),按color增序排列。 不要显示没有出现过的颜色。

20 20 3 2 2 18 18 2 0 8 19 19 3 8 0 10 19 4

1 91 2 84 3 187 4 38

0

 

 

2017-04-14 12:58:54

1

64

N

2

2

0

1324

USACO_3.1.5Contact 联系

奶牛们开始对用射电望远镜扫描牧场外的宇宙感兴趣。最近,他们注意到了一种非常奇怪的脉冲调制微波从星系的中央发射出来。他们希望知道电波是否是被某些地外生命发射出来的,还是仅仅是普通的的星星发出的。 帮助奶牛们用一个能够分析他们在文件中记下的记录的工具来找到真相。他们在寻找长度在AB之间(含)在每天的数据文件中重复得最多的比特序列 (1 <= A <= B <= 12)。他们在找那些重复得最多的比特序列。一个输入限制告诉你应输出多少频率最多的序列。 符合的序列可能会重叠,并且至少重复一次的序列会被计数。

第一行:三个用空格分隔的整数: A, B, N; (1 <= N < 50) 第二行及以后: 一个最多200000字符的序列,全是01; 每行有80个字符,除了可能的最后一行。

输出N个频率最高的序列(按照频率由高到低的次序)。由短到长排列频率相同的这些序列,如果长短相同,按二进制大小排列。如果出现的序列个数小于N,输出存在的序列。 对于每个存在的频率,先输出单独包含该频率的一行,再输出以空格分隔的这些频率。每行六个(除非少于六个剩下)。

2 4 10 01010010010001000111101100001010011001111000010010011110010000000

23 00 15 01 10 12 100 11 11 000 001 10 010 8 0100 7 0010 1001 6 111 0000 5 011 110 1000 4 0001 0011 1100

0

{在样例里,序列100出现了12次,而序列1000出现了5次。次数最多的序列是00,出现了23次。 }

 

2017-04-14 12:58:54

30

64

N

1

2

0

1325

USACO_3.1.6Stamps 邮票

已知一个 N 枚邮票的面值集合(如,{1 分,3 })和一个上限 K —— 表示信封上能够贴 K 张邮票。计算从 1  M 的最大连续可贴出的邮资。 例如,假设有 1 分和 3 分的邮票;你最多可以贴 5 张邮票。很容易贴出 1  5 分的邮资(用 1 分邮票贴就行了),接下来的邮资也不难: 6 = 3 + 3 7 = 3 + 3 + 1 8 = 3 + 3 + 1 + 1 9 = 3 + 3 + 3 10 = 3 + 3 + 3 + 1 11 = 3 + 3 + 3 + 1 + 1 12 = 3 + 3 + 3 + 3 13 = 3 + 3 + 3 + 3 + 1。 然而,使用 5  1 分或者 3 分的邮票根本不可能贴出 14 分的邮资。因此,对于这两种邮票的集合和上限 K=5,答案是 M=13 [规模最大的一个点的时限是3s]

 1 行: 两个整数,K  NK1 <= K <= 200)是可用的邮票总数。N1 <= N <= 50)是邮票面值的数量。 第 2  .. 文件末: N 个整数,每行 15 个,列出所有的 N 个邮票的面值,每张邮票的面值不超过 10000

 1 行:一个整数,从 1 分开始连续的可用集合中不多于 K 张邮票贴出的邮资数。

5 2 1 3

13

0

 

 

2017-04-14 12:58:54

300

64

N

3

3

0

1326

USACO_3.2教程:Knapsack Problems背包问题

目录 1 前提 2 示例问题:用录音带录音 3 抽象描述 4 解题想法 5 三个背包问题 5.1 小数背包问题 5.1.1 注意 5.1.2 延伸 5.2 整数背包问题 5.2.1 延伸 5.3 多重背包问题 5.3.1 延伸 6 示例问题 6.1 分数膨胀[1998 USACO National Championship] 6.1.1 分析 6.2 篱笆栏[1999 USACO Spring Open] 6.2.1 分析 6.3 装满你的油箱 6.3.1 分析 前提 贪心法(它是一种多步决策法,它总是作出在当前看来是最好的选择,它的考虑不是从整体出发,而只是某种意义上的局部最优,这样贪心法不能对所有问题达到整体最优解,但是对相当范围的许多问题都能够产生整体最优解。--译者) 动态规划(它是将问题进行逐步的划分来缩小问题的规模,直到可以求出子问题的解为止。分划子问题后,对应的子问题中含有大量的重复,这样就将重复地求解;在第一次遇到重复时把它解决,并将解保存起来,以备后面引用。动态规划法常用来求一个问题在某种意义下的最优解。--译者) 递归下降 示例问题:用录音带录音 农场主约翰最喜欢的爱好是制作一个Bessie喜欢的音乐合集磁带以便它在产奶时听。Bessie的产奶量取决于它产奶时所听的歌曲。已知一组歌曲(每首歌都由一对整数--此曲的长度(以秒计),听该首歌时的产奶量来表示)以及给挤奶的总时间。找到这样一组歌曲的集合,使得歌曲的总长度不超过给Bessie挤奶的总时间且使Bessie的产奶量达到最大。 抽象描述 已知一组物品--每个都有其尺寸和值(比如,重量),以及可用的总空间。找到这样一个集合,使得该集合的值的和最大,且其尺寸的和受某些限制所约束。集合中任何一个特定的项目的总数目/尺寸不能超过它的可利用率。 解题想法 视其为背包问题的一般方法是一个容量受限的背包使得放入其中的物品的值达到最大。以上述问题为例,Bessie产奶时听的音乐带就是背包,而那些歌就是放入背包中的物品。 三个背包问题 背包问题有三种形式: 小数背包问题 允许将小数表示的物品放入背包中的是小数背包问题。举例来说,如果物品是原油、飞机燃料、煤油而你的背包是一只水桶,取0.473升的原油,0,263升的飞机燃料和0,264升的煤油就是有意义的。这是形式最简单的要解决的背包问题。 整数背包问题 在整数背包问题中,只有完整的物品能放入背包里。此形式的一个例子就是:部分的曲子不允许放入包中。 多重背包问题 在多重背包问题中,需被填充的背包多于一个。如果允许有小数的物品放入,也就等于有一个大的背包,其容量相当于所有可用背包的和。因此,此术语只用来指多重整数背包的情况。 小数背包问题 小数背包问题是三者中最简单的,其贪心解法如下: 找到值密度(物品值/尺寸)最大的物品 如果总容量仍就超过物品的可利用率,把所有满足条件的物品放入背包中,然后反复执行。 如果总容量少于物品的可利用率,尽可能多的使用可用空间,然后终止。 由于这个算法必须先按照值密度把物品分类,然后以降序将它们放入背包,直至容量用完,该算法以N log N 级运行。通常简单些的方法不是将它们分类,而是不停地找每次不用的最大值密度,这种算法的时间复杂度是O(N^2) 。 注意 对于这类问题,因为你可以做一个微小的变换使得所有的物品尺寸大小为一,且原始尺寸大小和可利用率(当然用原始尺寸大小除值)的乘积就是总容量,同时有尺寸和可利用率是很少见的。 延伸 在这种情况下,物品的值和可利用率可以是实数。用这种算法处理有小数的尺寸大小也不是问题。 整数背包问题 这个问题有点难度,但是如果背包足够小,使用动态规划,它还是可解的。 依据背包大小的最大值设计动态的程序。 刷新用来表示大小为S的物品的数组,颠倒其次序,看将当前物品放入大小为K的背包中所产生的集合是否比当前最好的大小为K+S的背包更符合条件。 这个算法运行K*N次,其中K是背包的大小,N是物品的可利用率义之和。 如果背包太大了以至于无法分配此数组,递归下降是一种选择,即这个问题是NP完全的(给定I上的一个语言L,如果有一架非确定图灵机M和一个多项式P(n),对任何I上的长度为n的串wM都可以在P(n)步内确定是否接受w,则称L是非确定图灵机下多项式时间复杂性问题,简记为NP问题/语言。若L是属于NP的,且对NP中的每一个语言L',都存在一个从L'L的多项式时间转化,我们说LNP完整的。--译者)。当然,递归下降在以小的物品填充的大背包情况下可以运行相当长的一段时间。 延伸 小数的值不是问题;数组可以用实数数组来代替整数数组。小数的可利用率并不影响什么,在没有大量损失的条件下,缩短数字(如果你有3,5个物品,你可以仅用3)。 小数的尺寸是个讨厌的东西,它使得问题递归下降。 如果尺寸都相同,问题就能用贪心解,在下降的值排序中选择物品,直到背包满为止。 如果值都是1.0,同样地使用贪心法,在上升的尺寸大小排序中选择物品,直到背包满为止。 多重背包问题 对于任何大小的多重背包,状态空间太大了以至于无法使用从整数背包算法中来的DP解法。于是递归下降是解决这个问题的方法。 延伸 用递归下降,通常扩展就简单了。小数的尺寸和值就不是问题了,同样地值的计算功能也不是问题。 如果值都是同一个,那么如果能被放入所有背包中的物品的最大值是n,则存在使用n个最小物品的解法。它能大大减少查找时间。 示例问题 分数膨胀[1998 USACO National Championship] 你正试图设计一个有最高分数(<10,000)的比赛。已知比赛长度,一组问题,问题的长度以及每个问题的分值,计算满足长度约束的最高分数的比赛。 分析 这是一个整数背包问题,比赛是背包,尺寸是问题的长度,值是分数值。背包(比赛)尺寸的限制是其足够小使得解法在存储器中运行。 篱笆栏[1999 USACO Spring Open] 农场主约翰准备在他的领地建一圈篱笆。他已装好了柱子,所以他知道所要的围栏长度。当地的木材店有各种长度的木板(至多50个)。已知木材店木板的长度,约翰要的围栏长度,计算约翰建篱笆所用的围栏最大值。 分析 这是个多重背包问题,木材店的木板是背包,物品是约翰用的围栏。物品的尺寸就是长度,值是一。由于值都是一,如果存在用任意K个围栏的解法,则有用K个最小围栏的解法。 [编辑] 装满你的油箱 你在Beaver郡中部一百英里有一个加油站的城市中,想将你的油箱装满好能到达Rita Blanca。幸运地是,这个小镇有两三个加油站,但它们的油都好像要用光了。已知每个加油站的油价,每个加油站的油量,计算为了花最少的钱,应该从每个加油站买多少汽油。 分析 这是一个小数背包问题,背包是油箱,物品是汽油。

Knapsack Problems Prerequisite modules • Greedy • Dynamic Programming • Recursive Descent Sample Problem: Tape Recording Farmer John's favorite hobby is creating a tape containing some of Bessie's favorite music to listen to while she's being milked. The amount of milk that Bessie produces is dependent on the songs that Bessie listens to while being milked. Given a collection of songs, each represented by a pair of integers, the length of the song (in seconds), the amount of milk Bessie produces while she's listening to that song, and the total amount of time that it takes to milk Bessie, find the set of songs such that their total length is no more than the time it takes to milk Bessie and they maximize Bessie's milk production. The Abstraction Given, A collection of objects, each which a size, a value (i.e., weight), and the total `space' available, find the set of objects which maximizes the sum of the value of the set, but whose sum of size is constrained by some limit. The total number/size of any particular item used in the set cannot exceed its availability. Problem Viewpoint The general way to view a knapsack problem is that of a bag of limited capacity, which is to be filled while maximizing the value of the objects in it. For the problem above, the tape which Bessie will listen to while being milked is the ``knapsack,'' while the songs are the ``objects to be placed within the knapsack.'' Three Knapsack Problems The knapsack problem style has three forms: • Fractional knapsack problem A fractional knapsack problem is one in which you are allowed to place fractional objects in the knapsack. For example, if the objects were crude oil, airplane fuel, and kerosene and your knapsack a bucket, it might make sense to take 0.473 liter of the crude oil, 0.263 liter of the airplane fuel, and 0.264 liter of the kerosene. This is the easiest form of the knapsack problem to solve. • Integer Knapsack problem In integer knapsack problems, only complete objects can be inserted into the knapsack. The example problem is of this form: partial songs aren't allowed. • Multiple knapsack problem In the multiple knapsack problem, more than one knapsack is to be filled. If fractional objects are allowed, this is the same as having one large knapsack with capacity equal to the sum of all the available knapsacks, so this term will only be used to refer to the case of multiple integer knapsacks. Fractional knapsack problem The fractional knapsack problem is the easiest of the three to solve, as the greedy solution works: • Find the object which has the highest ``value density'' (value of object / size). • If the total amount of capacity remaining exceeds the availability of that object, put all of it in the knapsack and iterate. • If the amount of capacity is less than the availability of the object, use as much as possible and terminate. • This algorithm runs in N log N since it must sort the objects first based on value density and then put them into the knapsack in decreasing order until the capacity is used. It's normally easier to not sort them but rather just keep finding the highest value density not used each time, which gives a O(N 2) algorithm. Side note: For problems of this class, it's rare to have both size and availability, as you can do a trivial transformation to have all the objects of size 1, and the availability be the product of the original size and availability (dividing the value by the original size, of course). Extensions: The value and availability of the objects can be real numbers without a problem in this case. The fractional size issue is also trivial to handle by this algorithm. Integer knapsack problem This is slightly more difficult, but is solvable using dynamic programming if the knapsack is small enough. • Do dynamic programming on the maximum value that a knapsack of each size can have in it. • Update this array for an object of size S by traversing the array in reverse order (of capacity), and seeing if placing the current object into the knapsack of size K yields a better set than the current best knapsack of size K+S. • This algorithm runs in K x N time, where K is the size of the knapsack, and N is the sum of availability of objects. • If the knapsack is too large to allocate this array, recursive descent is the method of choice, as this problem is NP-complete. Of course, recursive descent can run for a very long time in a large knapsack being filled with small objects. Extensions: • Fractional values are not a problem; the array just becomes an array of real numbers instead of integers. Fractional availability doesn't affect things, as you can, without loss of generality, truncate the number (if you have 3.5 objects, you can only use 3). • Fractional size is a pain, as it makes the problem recursive descent. • If the sizes are all the same, the problem can be solved greedily, picking the objects in decreasing value order until the knapsack is full. • If the values are all 1.0, then again greedy works, selecting the objects in increasing size order until the knapsack is full. Multiple knapsack problem With multiple knapsacks of any size, the state space is too large to use the DP solution from the integer knapsack algorithm. Thus, recursive descent is the method to solve this problem. Extensions: • With recursive descent, extensions are generally easy. Fractional sizes and values are no problem, nor is another evaluation function. • If the values are all one, then if the maximum number of objects that can be placed in all the knapsacks is n, then there is such a solution which uses the n smallest objects. This can greatly reduce the search time. Sample Problems Score Inflation [1998 USACO National Championship] You are trying to design a contest which has the maximum number of points (<10,000). Given the length of the contest, a group of problems, the problem lengths, and the point value of each problem, find the contest which has the maximum number of points (which satisfies the length constraint). Analysis: This is an integer knapsack problem, where the knapsack is the contest, the sizes are the length of problems, and the values are the point values. The limit on knapsack (contest) size is small enough that the DP solution will work in memory. Fence Rails [1999 USACO Spring Open] Farmer John is trying to construct a fence around his field. He has installed the posts already, so he knows the length requirement of the rails. The local lumber store has dropped off some boards (up to 50) of varying length. Given the length of the boards from the lumber store, and the lengths of rails that Farmer John needs, calculate the maximum numbers of rails that Farmer John can create. Analysis: This is a multiple knapsack problem, where the knapsacks are the boards from the store, and the objects are the rails that Farmer John needs. The size of the objects are just the length, and the value is just one. Since the values are all one, you know that if there is a solution using any K rails, there is a solution using the K smallest rails, which helps the recursive descent solver quite a bit. Filling your Tank You're in the middle of Beaver County, at the only city within 100 miles with a gas station, trying to fill up your tank so you can get to Rita Blanca. Fortunately, this town has a couple of gas stations, but they all seem to be almost out of gas. Given the price of gasoline at each station, and the amount of gas each one has, calculate how much gasoline to buy from each station in order to minimize the total cost. Analysis: This is an fractional knapsack problem, where your knapsack is your gas tank, and the objects are gasoline.

 

 

 

0

 

 

2017-04-14 12:58:54

1

64

N

2

2

0

1327

USACO_3.2.1Factorials阶乘

N的阶乘写作N!表示小于等于N的所有正整数的乘积。 阶乘会很快的变大,如13!就必须用32位整数类型来存储,70!即使用浮点数也存不下了。 你的任务是找到阶乘最后面的非零位。举个例子: 5!=1*2*3*4*5=120所以5!的最后面的非零位是2 7!=1*2*3*4*5*6*7=5040,所以最后面的非零位是4

共一行,一个整数不大于4,220的整数N

共一行,输出N!最后面的非零位。

7

4

0

 

 

2017-04-14 12:58:54

1

64

N

3

3

0

1328

USACO_3.2.2Stringsobits01

考虑排好序的N(N<=31)位二进制数。 你会发现,这很有趣。因为他们是排列好的,而且包含所有可能的长度为N且含有1的个数小于等于L(L<=N)的数。 你的任务是输出第i1<=i<=长度为N的二进制数的个数)小的,长度为N,且含有1的个数小于等于L的那个二进制数。

共一行,用空格分开的三个整数NLi

共一行,输出满足条件的第i小的二进制数。

5 3 19

10011

0

 

 

2017-04-14 12:58:54

1

64

N

3

3

0

1329

USACO_3.2.3Spinning Wheels纺车的轮子

1998 ACM NE Regionals 一架纺车有五个纺轮,这五个不透明的轮子边缘上都有一些缺口。这些缺口必须被迅速而准确地排列好。每个轮子都有一个起始标记(在0度),这样所有的轮子都可以在统一的已知位置开始转动。轮子按照角度变大的方向旋转,所以从起始位置开始,在一定的时间内,它们依次转过1度,2度等等(虽然这些轮子很可能不会同时转过这些角度)。 这是一个整数问题。轮子不会转过1.5度或23.51234123度这样的角度。例如,轮子可能在一秒钟内转过2025度甚至3040度(如果转得快的话)。 这个问题中的所有角度都限制在 0 <= 角度 <= 359 这个范围内。轮子转过 359 度后接下来就是 0 度。每个轮子都有一个确定的旋转速度,以秒作为单位。1 <= 速度 <= 180。 轮子上的缺口的起始角度和缺口大小(或长度)各由一个整数表示,都以度为单位。在一个轮子上,两个缺口之间至少有一度的间隔。 在起始位置,设时间为 0,所有的轮子的起始标记排列成一条直线。你的程序必须计算,最早出现每个的轮子上的缺口同其他轮子上的缺口对准(也就是一束光可以通过五个轮子上的五个缺口)情况的时间。这些缺口在任意一个角度对准。

输入中的五行对应五个轮子。 第一个数字表示轮子的转动速度。下一个数字是缺口的数目 W1 <= W <= 5。接下来的 W 对数字表示每个缺口的起始角度和长度。

只有一行,包括一个整数,表示光能够通过这五个轮子的最早时间。如果无解,输出'none'(小写,不含引号)。

30 1 0 120 50 1 150 90 60 1 60 90 70 1 180 180 90 1 180 60

9

0

 

1998 ACM NE Regionals

2017-04-14 12:58:54

1

64

N

3

3

0

1330

USACO_3.2.4Feed Ratios饲料调配

1998 ACM Finals, Dan Adkins 农夫约翰从来只用调配得最好的饲料来喂他的奶牛。饲料用三种原料调配成:大麦,燕麦和小麦。他知道自己的饲料精确的配比,在市场上是买不到这样的饲料的。他只好购买其他三种混合饲料(同样都由三种麦子组成),然后将它们混合,来调配他的完美饲料。 给出三组整数,表示 大麦:燕麦:小麦 的比例,找出用这三种饲料调配 xyz 的饲料的方法。 例如,给出目标饲料 345 和三种饲料的比例: 1:2:3 3:7:1 2:1:2 你必须编程找出使这三种饲料用量最少的方案,要是不能用这三种饲料调配目标饲料,输出“NONE”用量最少意味着三种饲料的用量(整数)的和必须最小。 对于上面的例子,你可以用8份饲料11份饲料2,和5份饲料3,来得到7份目标饲料: 8*(1:2:3) + 1*(3:7:1) + 5*(2:1:2) = (21:28:35) = 7*(3:4:5) 表示饲料比例的整数,都是小于100的非负整数。表示各种饲料的份数的整数,都小于100。一种混合物的比例不会由其他混合物的比例直接相加得到。

Line 1: 三个用空格分开的整数,表示目标饲料 Line 2..4: 每行包括三个用空格分开的整数,表示农夫约翰买进的饲料的比例

输出文件要包括一行,这一行要么有四个整数,要么是“NONE”。前三个整数表示三种饲料的份数,用这样的配比可以得到目标饲料。第四个整数表示混合三种饲料后得到的目标饲料的份数。

3 4 5 1 2 3 3 7 1 2 1 2

8 1 5 7

0

 

1998 ACM Finals, Dan Adkins

2017-04-14 12:58:54

1

64

N

3

3

0

1331

USACO_3.2.5Magic Squares 魔板

IOI'96 在成功地发明了魔方之后,鲁比克先生发明了它的二维版本,称作魔板。这是一张有8个大小相同的格子的魔板: 1 2 3 4 8 7 6 5 我们知道魔板的每一个方格都有一种颜色。这8种颜色用前8个正整数来表示。可以用颜色的序列来表示一种魔板状态,规定从魔板的左上角开始,沿顺时针方向依次取出整数,构成一个颜色序列。对于上图的魔板状态,我们用序列(12345678)来表示。这是基本状态。 这里提供三种基本操作,分别用大写字母“A”“B”“C”来表示(可以通过这些操作改变魔板的状态): “A”:交换上下两行; “B”:将最右边的一列插入最左边; “C”:魔板中央四格作顺时针旋转。 下面是对基本状态进行操作的示范: A: 8 7 6 5 1 2 3 4 B: 4 1 2 3 5 8 7 6 C: 1 7 2 4 8 6 3 5 对于每种可能的状态,这三种基本操作都可以使用。 你要编程计算用最少的基本操作完成基本状态到目标状态的转换,输出基本操作序列。

只有一行,包括8个整数,用空格分开(这些整数在范围 1——8 之间),表示目标状态。

Line 1: 包括一个整数,表示最短操作序列的长度。 Line 2: 在字典序中最早出现的操作序列,用字符串表示,除最后一行外,每行输出60个字符。

2 6 8 4 5 7 3 1

7 BCABCCB

0

 

 

2017-04-14 15:24:12

1

64

N

0

1

0

1332

USACO_3.2.6Sweet Butter香甜的黄油

Greg Galperin -- 2001 农夫John发现做出全威斯康辛州最甜的黄油的方法:糖。把糖放在一片牧场上,他知道N1<=N<=500)只奶牛会过来舔它,这样就能做出能卖好价钱的超甜黄油。当然,他将付出额外的费用在奶牛上。 农夫John很狡猾。像以前的巴甫洛夫,他知道他可以训练这些奶牛,让它们在听到铃声时去一个特定的牧场。他打算将糖放在那里然后下午发出铃声,以至他可以在晚上挤奶。 农夫John知道每只奶牛都在各自喜欢的牧场(一个牧场不一定只有一头牛)。给出各头牛在的牧场和牧场间的路线,找出使所有牛到达的路程和最短的牧场(他将把糖放在那)

第一行: 三个数:奶牛数N,牧场数P2<=P<=800),牧场间道路数C(1<=C<=1450) 第二行到第N+1: 1N头奶牛所在的牧场号 第N+2行到第N+C+1行: 每行有三个数:相连的牧场AB,两牧场间距离D1<=D<=255),当然,连接是双向的

一行 输出奶牛必须行走的最小的距离和

3 4 5 2 3 4 1 2 1 1 3 5 2 3 7 2 4 3 3 4 5 样例图形 P2 P1 @--1--@ C1 \ |\ \ | \ 5 7 3 \ | \ \| \ C3 C2 @--5--@ P3 P4

8 {说明:放在4号牧场最优 }

0

 

 

2017-04-14 16:17:53

30

64

N

0

2

0

1333

USACO_3.3教程:Eulerian Tour欧拉路径

Eulerian Tour 欧拉路径 译 by 孖哥 and tim green Sample Problem: Riding The Fences   农民John每年有很多栅栏要修理。他总是骑着马穿过每一个栅栏并修复它破损的地方。   John是一个与其他农民一样懒的人。他讨厌骑马,因此从来不两次经过一个一个栅栏。你必须编一个程序,读入栅栏网络的描述,并计算出一条修栅栏的路径,使每个栅栏都恰好被经过一次。John能从任何一个顶点(即两个栅栏的交点)开始骑马,在任意一个顶点结束。   每一个栅栏连接两个顶点,顶点用1500标号(虽然有的农场并没有500个顶点)。一个顶点上可连接任意多(>=1)个栅栏。所有栅栏都是连通的(也就是你可以从任意一个栅栏到达另外的所有栅栏)。   你的程序必须输出骑马的路径(用路上依次经过的顶点号码表示)。我们如果把输出的路径看成是一个500进制的数,那么当存在多组解的情况下,输出500进制表示法中最小的一个 (也就是输出第一个数较小的,如果还有多组解,输出第二个数较小的,等等)。   输入数据保证至少有一个解。 The Abstraction 已知:一幅无向图 寻找一条只过每边一次的路径.这条路径叫欧拉路径(Eulerian tour).如果此路 径和起点和终点是同一点,则此种路径叫欧拉回路. The Algorithm 判断一幅图有没有欧拉路径或欧拉回路是很简单,有两个不同的规则可用. 当且仅当一幅图是相连的(只要你去掉所有度数为0的点)且每个点的度都是偶数,这幅图有欧拉回路. 当且仅当一幅图是相连的且除两点外所有的点的度都是偶数. 在第二种情况中,那两个度为奇数的节点一个为起点,剩下的一个是终点. 一个解决此类问题基本的想法是从某个节点开始,然后查出一个从这个点出发回到这个点的环路径。现在,环已经建立,这种方法保证每个点都被遍历.如果有某个点的边没有被遍历就让这个点为起点,这条边为起始边,把它和当前的环衔接上。这样直至所有的边都被遍历。这样,整个图就被连接到一起了。 更正式的说,要找出欧拉路径,就要循环地找出出发点。按以下步骤: 任取一个起点,开始下面的步骤 如果该点没有相连的点,就将该点加进路径中然后返回。 如果该点有相连的点,就列一张相连点的表然后遍历它们直到该点没有相连的点。(遍历一个点,删除一个点) 处理当前的点,删除和这个点相连的边, 在它相邻的点上重复上面的步骤,把当前这个点加入路径中. 下面是伪代码: # circuit is a global array find_euler_circuit circuitpos = 0 find_circuit(node 1) # nextnode and visited is a local array # the path will be found in reverse order find_circuit(node i) if node i has no neighbors then circuit(circuitpos) = node i circuitpos = circuitpos + 1 else while (node i has neighbors) pick a random neighbor node j of node i delete_edges (node j, node i) find_circuit (node j) circuit(circuitpos) = node i circuitpos = circuitpos + 1 要找欧拉路径, 只要简单的找出一个度为奇数的节点,然后调用 find_circuit 就可以了. 这两个算法的效率都是 O(m + n), m 是边数, n 是节点数, i如果你用邻接表来储存图, 有可能会使程序堆栈溢出, 所以你要用自己的堆栈. Execution Example 考虑下面这个图: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler1.gif> 假定随机选择相邻的节点时从编号最小的开始,下面是执行的结果: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2a.gif>   Stack: Location: 1 Circuit: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2b.gif>   Stack: 1 Location: 4 Circuit: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2c.gif>   Stack: 1 4 Location: 2 Circuit: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2d.gif>   Stack: 1 4 2 Location: 5 Circuit: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2e.gif>   Stack: 1 4 2 5 Location: 1 Circuit: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2e.gif>   Stack: 1 4 2 Location: 5 Circuit: 1 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2f.gif>   Stack: 1 4 2 5 Location: 6 Circuit: 1 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2g.gif>   Stack: 1 4 2 5 6 Location: 2 Circuit: 1 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2h.gif>   Stack: 1 4 2 5 6 2 Location: 7 Circuit: 1 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2i.gif>   Stack: 1 4 2 5 6 2 7 Location: 3 Circuit: 1 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2j.gif>   Stack: 1 4 2 5 6 2 7 3 Location: 4 Circuit: 1 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2k.gif>   Stack: 1 4 2 5 6 2 7 3 4 Location: 6 Circuit: 1 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2l.gif>   Stack: 1 4 2 5 6 2 7 3 4 6 Location: 7 Circuit: 1 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: 1 4 2 5 6 2 7 3 4 6 7 Location: 5 Circuit: 1 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: 1 4 2 5 6 2 7 3 4 6 Location: 7 Circuit: 1 5 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: 1 4 2 5 6 2 7 3 4 Location: 6 Circuit: 1 5 7 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: 1 4 2 5 6 2 7 3 Location: 4 Circuit: 1 5 7 6 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: 1 4 2 5 6 2 7 Location: 3 Circuit: 1 5 7 6 4 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: 1 4 2 5 6 2 Location: 7 Circuit: 1 5 7 6 4 3 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: 1 4 2 5 6 Location: 2 Circuit: 1 5 7 6 4 3 7 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: 1 4 2 5 Location: 6 Circuit: 1 5 7 6 4 3 7 2 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: 1 4 2 Location: 5 Circuit: 1 5 7 6 4 3 7 2 6 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: 1 4 Location: 2 Circuit: 1 5 7 6 4 3 7 2 6 5 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: 1 Location: 4 Circuit: 1 5 7 6 4 3 7 2 6 5 2 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: Location: 1 Circuit: 1 5 7 6 4 3 7 2 6 5 2 4 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/euler/euler2m.gif>   Stack: Location: Circuit: 1 5 7 6 4 3 7 2 6 5 2 4 1 Extensions 两个点之间有多条边的图,也可以使用相同的算法。 有自环的图也可以使用这样的算法, 前提是我们自环给这个节点增加的度为2. 如果一个有向图是强连通的 (不考虑入 度出度都是0的点) 并且每个点的入度等于出度。那么这个图有欧拉回路而这个算法仍然适用,但是你要记得输出时应该从最后一个开始。 在有向图中寻找一个欧拉路径是十分困难的。 Example problems Airplane Hopping 忙碌的飞机 给出地图上的城市, 在一些城市之间有航线, 请确定是否存在一条路线,使得飞机飞遍每一条航线又回到它出发的城市。 分析: 这等价于在一个有向图中找欧拉回路。 Cows on Parade 奶牛游行 农民John有两种牛: 黑色的 Angus和白色的 Jerseys. While marching John的妻子Joanne19只母牛去集市时,她注意到4只母牛排要一起的全部的16种情况(e.g., bbbb, bbbw, bbwb, bbww, ..., wwww)。当然,一些情况和另一些是有重叠的. 给出 N (2 <= N <= 15), 找出长度最短的一个母牛序列使得N只母牛排在一起的所有情况在这个序列中都出现过。 分析: 这个图中的顶点是N1只母牛排在一起的所有情况. [Being at a node corresponds to the last N-1 cows matching the node in color.]  N = 4,如果最后3只母牛是 wbw, 那么你就停在节点 wbw 。 因为可能相应的增加wb到序列的最后,所以每个点的出度为2。 同样,可能相应的增加wb到序列的开始,所以每个点的入度为也2。 这个图是强连通的,并且入度等于出度, 所以存在欧拉回路.。 欧拉回路对应的序列是欧拉回路中第一个点对应的N-1序列加上后面边的颜色。

 

 

 

 

0

 

 

2017-04-15 21:09:08

1

64

N

2

2

0

1334

USACO_3.3.1Riding the Fences骑马修栅栏

农民John每年有很多栅栏要修理。他总是骑着马穿过每一个栅栏并修复它破损的地方。 John是一个与其他农民一样懒的人。他讨厌骑马,因此从来不两次经过一个栅栏。你必须编一个程序,读入栅栏网络的描述,并计算出一条修栅栏的路径,使每个栅栏都恰好被经过一次。John能从任何一个顶点(即两个栅栏的交点)开始骑马,在任意一个顶点结束。 每一个栅栏连接两个顶点,顶点用1500标号(虽然有的农场并没有500个顶点)。一个顶点上可连接任意多(>=1)个栅栏。所有栅栏都是连通的(也就是你可以从任意一个栅栏到达另外的所有栅栏)。 你的程序必须输出骑马的路径(用路上依次经过的顶点号码表示)。我们如果把输出的路径看成是一个500进制的数,那么当存在多组解的情况下,输出500进制表示法中最小的一个 (也就是输出第一个数较小的,如果还有多组解,输出第二个数较小的,等等)。 输入数据保证至少有一个解。

1: 一个整数F(1 <= F <= 1024),表示栅栏的数目 第2F+1: 每行两个整数i, j(1 <= i,j <= 500)表示这条栅栏连接ij号顶点。

输出应当有F+1行,每行一个整数,依次表示路径经过的顶点号。注意数据可能有多组解,但是只有上面题目要求的那一组解是认为正确的。

9 1 2 2 3 3 4 4 2 4 5 2 5 5 6 5 7 4 6

1 2 3 4 2 5 4 6 5 7

0

 

 

2017-04-15 21:09:08

1

64

N

2

2

0

1335

USACO_3.3.2Shopping Offers商店购物

IOI'95 在商店中,每一种商品都有一个价格(用整数表示)。例如,一朵花的价格是 2 zorkmids z),而一个花瓶的价格是 5z 。为了吸引更多的顾客,商店举行了促销活动。 促销活动把一个或多个商品组合起来降价销售,例如: 三朵花的价格是 5z 而不是 6z, 两个花瓶和一朵花的价格是 10z 而不是 12z。 编写一个程序,计算顾客购买一定商品的花费,尽量利用优惠使花费最少。尽管有时候添加其他商品可以获得更少的花费,但是你不能这么做。 对于上面的商品信息,购买三朵花和两个花瓶的最少花费是:以优惠价购买两个花瓶和一朵花(10z),以原价购买两朵花(4z)。

输入文件包括一些商店提供的优惠信息,接着是购物清单。 第一行 优惠商品的种类数(0 <= s <= 99)。 第二行..s+1 行 每一行都用几个整数来表示一种优惠方式。第一个整数 n 1 <= n <= 5),表示这种优惠方式由 n 种商品组成。后面 n 对整数 c  k 表示 k 1 <= k <= 5)个编号为 c 1 <= c <= 999)的商品共同构成这种优惠,最后的整数 p 表示这种优惠的优惠价(1 <= p <= 9999)。优惠价总是比原价低。 第 s+2 行 这一行有一个整数 b 0 <= b <= 5),表示需要购买 b 种不同的商品。 第 s+3 .. s+b+2 行 这 b 行中的每一行包括三个整数:c k ,和 p  C 表示唯一的商品编号(1 <= c <= 999),k 表示需要购买的 c 商品的数量(1 <= k <= 5)。p 表示 c 商品的原价(1 <= p <= 999)。最多购买 5*5=25 个商品。

只有一行,输出一个整数:购买这些物品的最低价格。

2 1 7 3 5 2 7 1 8 2 10 2 7 3 2 8 2 5

14

0

 

 

2017-04-15 21:09:08

1

64

N

2

3

0

1336

USACO_3.3.3Camelot亚瑟王的宫殿

IOI 98 很久以前,亚瑟王和他的骑士习惯每年元旦去庆祝他们的友谊。为了纪念上述事件,我们把这些是看作是一个有一人玩的棋盘游戏。有一个国王和若干个骑士被放置在一个由许多方格组成的棋盘上,没有两个骑士在同一个方格内。 这个例子是标准的8*8棋盘 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/camelot/camelot-1.gif> 国王可以移动到任何一个相邻的方格,从下图中黑子位置到下图中白子位置前提是他不掉出棋盘之外。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/camelot/camelot-2.gif> 一个骑士可以从下图中黑子位置移动到下图中白子位置(字形) 但前提是他不掉出棋盘之外。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/camelot/camelot-3.gif> 在游戏中,玩家可在每个方格上放不止一个棋子,假定方格足够大,任何棋子都不会阻碍到其他棋子正常行动。 玩家的任务就是把所有的棋子移动到同一个方格里——用最小的步数。为了完成这个任务,他必须按照上面所说的规则去移动棋子。另外,玩家可以选择一个骑士跟国王从他们两个相遇的那个点开始一起行动,这时他们按照骑士的行动规则行动,其他的单独骑士则自己一直走到集中点。骑士和国王一起走的时候,只算一个人走的步数。 写一个程序去计算他们集中在一起的最小步数,而且玩家必须自己找出这个集中点。当然,这些棋子可以在棋盘的任何地方集合。

第一行: 两个用空格隔开的整数:R,C 分别为棋盘行和列的长。不超过26列,30行。 第二行..结尾: 输入文件包含了一些有空格隔开的字母/数字对,一行有一个或以上。第一对为国王的位置,接下来是骑士的位置。可能没有骑士,也可能整个棋盘都是骑士。行从1开始,列从大写字母A开始。

单独一行表示棋子集中在一个方格的最小步数。

8 8 D 4 A 3 A 8 H 1 H 8 {国王位置在D4。一共有四个骑士,位置分别是A3,A8,H1H8}

10 {他们集中在B5。 骑士1: A3 - B5 (1) 骑士2: A8 - C7 - B5 (2) 骑士3: H1 - G3 - F5 - D4 (此时国王开始与这个骑士一起走) - B5 (4) 骑士4: H8 - F7 - D6 - B5 (3) 1 + 2 + 4 + 3 = 10 }

0

 

 

2017-04-15 21:09:08

3

64

N

0

2

0

1337

USACO_3.3.4Home on the Range家的范围

农民约翰在一片边长是N (2 <= N <= 250)英里的正方形牧场上放牧他的奶牛。(因为一些原因,他的奶牛只在正方形的牧场上吃草。)遗憾的是,他的奶牛已经毁坏一些土地。( 一些1平方英里的正方形) 农民约翰需要统计那些可以放牧奶牛的正方形牧场(至少是2x2,在这些较大的正方形中没有一个点是被破坏的,也就是说,所有的点都是“1”)。 你的工作要在被供应的数据组里面统计所有不同的正方形放牧区域(>=2x2)的个数。当然,放牧区域可能是重叠。

 1 :N,牧区的边长。 第 2 到 n+1:N个没有空格分开的字符。 0 表示 "那一个区段被毁坏了";1 表示 " 准备好被吃"

输出那些存在的正方形的边长和个数,一种一行。

6 101111 001111 111111 001111 101101 111001

2 10 3 4 4 1

0

 

 

2017-04-15 21:09:08

1

64

N

6

8

0

1338

USACO_3.3.5A Game游戏

IOI'96 - Day 1 有如下一个双人游戏:N(2 <= N <= 100)个正整数的序列放在一个游戏平台上,两人轮流从序列的两端取数,取数后该数字被去掉并累加到本玩家的得分中,当数取尽时,游戏结束。以最终得分多者为胜。 编一个执行最优策略的程序,最优策略就是使自己能得到在当前情况下最大的可能的总分的策略。你的程序要始终为两位玩家执行最优策略。

第一行: 正整数N, 表示序列中正整数的个数。 第二行至末尾: 用空格分隔的N个正整数(大小为1-200)。

只有一行,用空格分隔的两个整数: 依次为玩家一和玩家二最终的得分。

6 4 7 2 9 5 2

18 11

0

 

 

2017-04-15 21:09:08

1

64

N

3

4

0

1339

USACO_3.4教程:Computational Geometry计算几何

Computational Geometry 计算几何 译 By SuperBrother 目录 • 1 知识准备 • 2 操作 o 2.1 叉积 o 2.2 点积 o 2.3 反正切 • 3 全面考虑问题 • 4 一些几何算法 o 4.1 三角形面积 o 4.2 两条线段平行吗? o 4.3 多边形面积 o 4.4 点到直线的距离 o 4.5 点在直线上 o 4.6 点都在直线的同侧 o 4.7 点在线段上 o 4.8 点在三角形内 o 4.9 点在凸多边形内 o 4.10 四点(或更多)共面 o 4.11 两条直线相交 o 4.12 两条线段相交 o 4.13 两直线的交点 o 4.14 判断平面内多边形的凹凸性 o 4.15 点在凹多边形内 • 5 几何方法 o 5.1 蒙特卡洛方法(Monte Carlo) o 5.2 分割技术 o 5.3 转化为图 • 6 例子 o 6.1 Point Moving o 6.2 Bicycle Routing o 6.3 Maximizing Line Intersections o 6.4 Polygon Classification 知识准备 图论 最短路 操作 这个模块讨论几个计算某些几何问题的算法,这些算法大多基于下列两个操作:叉积和反正切。 叉积 uv的叉积被表示成u x v。两个三维的向量u,v的叉积是下列行列式(i,j,kx,y,z轴上单位向量): | i j k | | ux uy uz | | vx vy vz | : (uyvz-vyuz)i + (uzvx-uxvz)j + (uxvy-uyvx)k <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom6.gif> z分量为0时,上面式子就化为2维的两向量叉积了。结果只有z分量。 叉积有3个特点: 两个向量的叉积是一个与这两个向量同时垂直的向量。 叉积的大小等于下面3个量的乘积: o u的大小 o v的大小 o u,v夹角的正弦。 当然与u,v同时垂直的向量有两个方向,叉积的方向取决于uv的右边还是在v的左边。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom7.gif> 点积 两个向量u,v的点积是一个标量,用u • v表示。在三维空间中它被定义为:uxvx + uyvy + uzvz。 点积的值由以下三个值确定: • u的大小 • v的大小 • u,v夹角的余弦。 在u,v非零的前提下,点积如果为负,则u,v形成的角大于90度;如果为零,那么u,v垂直;如果为正,那么u,v形成的角为锐角。 反正切 反正切函数对于一个给定的正切值,返回一个在-pi/2pi/2之间的角。C中另外有一个函数atan2,给出y分量和x分量(注意顺序!),计算向量与x正半轴的夹角,在-pipi之间。它的优点就是不需担心被0除,也不需为了处理x为负的情况而写代码修改角。atan2函数几乎比普通的atan函数更简单,因为只需调用一次。 全面考虑问题 这些几何问题大多都产生很多特殊情况。注意这些特殊情况并且要保证自己的程序能处理所有的情况。 浮点运算也会带来新问题。浮点运算很难精确,因为注意:计算机只能计算一定精度。特别地,当判断两个值是否相等时,要判断两个值的差在一个很小的范围内,而不是直接相等。 一些几何算法 这里是一些能帮助你计算几何问题的东西。 三角形面积 为了计算由点(A,B,C)构成的三角形的面积,先选取一个顶点(例如A),再向剩余两个顶点作向量(令u=b-a, v=c-a)。三角形(A,B,C)的面积即为u,v叉积长度的一半。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom1.gif> 另一个求三角形面积的变通方法就是用海伦公式。如果三角形三边长为a,b,c,令s=(a+b+c)/2,那么三角形面积就是: sqrt(s*(s-a)*(s-b)*(s-c)) 两条线段平行吗? 为了判断两条线段是否平行,分别沿两条线段建立向量,判断叉积是否(几乎为)零。 多边形面积 由点(x1,y1)...(xn,yn)组成的多边形的面积等于下列行列式的值: 1 | x1 x2 ... xn | --- | | 2 | y1 y2 ... yn | 也等于下面的式子的值: x1y2 + x2y3 + ... + xny1 - y1x2 - y2x3 - ... - ynx1 点到直线的距离 点P到直线AB的距离也可以由叉积给出,准确的说,d(P,AB) = |(P - A) x (B - A)| / | B - A| 。 为了点P到由点A,BC确定的平面的距离,令n = (B - A) x (C - A),那么d(P,ABC) = (P-A) • n / |n|。 点在直线上 如果点到直线的距离是0,那么点在直线上。 点都在直线的同侧 只讲两个点的情况。如果要确定点CD是否在直线AB同侧,计算(B - A) x (C - A)(B - A) x (D - A)z分量。如果同号(或如果积为正),那么点C,D在直线AB同侧。 点在线段上 为了求出点C是否在线段AB上,先判断点A是否在直线AB上,再判断线段AB的长度是否等于线段AC长度与线段BC长度之和。 点在三角形内 要确定点A是否在三角形内,首先选择一个三角形内部的点B(重心就很不错)。接下来,判断点A,B是否都在三边所在的三条直线的同侧。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom3.gif> 点在凸多边形内 方法同上 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom4.gif> 四点(或更多)共面 如果要确定一组点是否共面,任选3个点。如果对于任意点D,有(B - A) x (C - A)) • (D - A) = ~0,那么这些点共面。 两条直线相交 平面内两条直线相交当且仅当直线不平行。 空间内,两直线AB,CD相交则AB,CD不平行,且点A,B,C,D共面。 两条线段相交 平面内,两条线段相交当且仅当A,B在线段CD异侧且C,D在线段AB异侧。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom5.gif> 注意两个判断都是必须的,例如第三种情况第一个判断为true,但第二个判断说明线段AB,CD不相交。在空间中,计算下面方程组,其中i,j未知: Ax + (Bx - Ax) i = Cx + (Dx - Cx) j Ay + (By - Ay) i = Cy + (Dy - Cy) j Az + (Bz - Az) i = Cz + (Dz - Cz) j 如果方程组有解(i,j)满足0<=i<=10<=j<=1,那么两线段相交于点(Ax + (Bx - Ax)i, Ay + (By - Ay)i, Az + (Bz - Az) i) 两直线的交点 在平面内的两条直线AB,CD,求交点最直接的方法就是解下列的二元二次方程组: Ax + (Bx - Ax)i = Cx + (Dx - Cx) j Ay + (By - Ay)i = Cy + (Dy - Cy) j 交点是: (Ax + (Bx - Ax) i, Ay + (By - Ay) i) 空间内,解同样的方程组来判断交点,交点是: (Ax + (Bx - Ax)i, Ay + (By - Ay)i, Az + (Bz - Az)i) 判断平面内多边形的凹凸性 要判断平面内一多边形是否为凸,沿着顺时针方向扫一遍。对于每三个点(A,B,C),计算叉积(B - A) x (C - A)。如果叉积的z分量均为负,多边形则为凸多边形。 点在凹多边形内 要确定点是否在凹多边形内,任选一点作射线,计算相交次数。如果与多边形相交于一点或一边,则换一个方向,否则,点在多边形内当且仅当射线与点相交次数为奇数。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom8.gif> 这个方法也可以扩展到三位(或更高),但此时应相交于面(再判断),不是在点上或边上。 几何方法 这些几何方法介绍了一些技巧,可以用来优化时间和求得更精确的解。 蒙特卡洛方法(Monte Carlo) 第一个方法是建立在随机化之上的。它不去直接计算某件事的概率,而是以一个随机事件来模拟,求得事件发生的频率。如果次数足够,频率和概率的差别会很小。 这对于确定某些东西来说是很有用的,例如计算某个图形的面积。它不去直接计算面积,而是建立一个有大小的立方体,每次向箱子扔一个飞镖,并计算击中图形的频率。如果计算足够精确,就可以得到实际面积的一个足够好的近似值。 这个方法要得到一个足够小的相对误差(误差于实际值之商),需要大量成功发生的事件。如果发生的概率很小,结果就不好了。 分割技术 分割技术可用来优化时间。这需要把平面分割成小块(通常是分成小格,但有时也会用角度或其它方法),并将元素放入合适的区域中。当检查图案的某部分时,只有有该图案的格子会被检查到。所以,时间可以大大地优化,比如,要确定到定点的距离小于某个值的元素(此时图案是个圆),或求是否相交(此时图案为直线)。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom9.gif> 转化为图 有时看起来像几何问题的的确是一个图的问题。因为输入是平面内的点,并不代表问题是几何问题。 例子 Point Moving 给定一组线段和点A,B,能否在不穿过线段的情况下从A移动到B? 线段将平面分割成不同部分,检查A,B是否在一个部分。 Bicycle Routing 给出有起点和终点的一组建筑物,找出从建筑物AB不穿过任何建筑物的最短路线。 题解:图论问题。以建筑物的起点和重点为点,两点之间在不径直穿过任何建筑物时连一条边,边权为两点之间的距离。这样就把原问题转化成了最短路问题。 Maximizing Line Intersections 给出平面内一组点,找到能被一条直线能相交到的最多线段。 题解:很显然,直线必须经过两个交点。这样,枚举每对交点,计算此时直线的交点数。可用分割法优化。 Polygon Classification 给出一组直线所确定的多边形,判断多边形是否是简单的(没有任意两条不连续的线段相交)和凸的. <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/cowhead2.gif>Computational Geometry Prerequisites Graph Theory Shortest Path Tools This module discusses several algorithms that calculate various geometric properties, mostly based on only two operations described below: cross product and arctangent. Cross Product The cross product of u and v is written as u x v. Computationally, the cross product of two three-dimensional vectors u and v is the vector determinant of the following matrix (where i, j, and k are unit vectors in the x, y, and z directions respectively): | i j k | | ux uy uz | | vx vy vz | That equation works out to: (uyvz-vyu z)i + (uzvx-u xvz)j + (uxv y-uyvx)k <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom6.gif> This definition can be used for vectors in two dimensions by using three-dimensional vectors with a z component of 0. The resulting vector will only have a z value. The cross product has three properties: The cross product of two vectors is perpendicular to both vectors. The length of the cross product is equal to the product of: the length of u, the length of v, and the sine of the angle between the vectors. Of the two different directions that are perpendicular to both u and v, the direction the cross product points depends on whether u is ``to the right'' of v or ``to the left.'' <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom7.gif> Dot product The dot product of two vectors u and v is a scalar written as u · v. Computationally, it is defined in three dimensions as: uxvx + u yvy + uzv z The dot product is actually equal to the product of: the length of u the length of v the cosine of the angle between u and v. Presuming u and v are non-zero, if the dot product if negative, u and v make an angle greater than 90 degrees. If it is zero, then u and v are perpendicular. If u cdot v is positive, then the two vectors form an acute angle. Arctangent The arctangentfunction calculates the (an) angle whose tangent is its argument and generally returns a real number between -pi/2 and pi/2. An additional function in C, atan2, takes two arguments: a DELTA y value and a DELTA x value (in that order!). It determines the angle between the given vector and the positive x axis and returns a value between -pi and pi. This has the advantage of removing concerns about dividing by zero or writing code to repair angles in order to handle the negative x cases. The atan2 function is almost always easier to use than the simpler atan function that takes only one argument. Particular Debugging Problems The main problem with geometric problems is that they spawn a lot of special cases. Be on the lookout for these special cases and make sure your program works for all of them. Floating point calculations also create a new set of problems. Floating point calculations are rarely precise, as the computer only maintains so many bits (digits) of accuracy: be aware of this. In particular, when checking if two values are equal, check to see if they are within some small tolerance of each other not precisely equal. Geometric Algorithms Here are some of snippets that can help you solve geometry problems. Area of Triangle To calculate the area of a triangle with vertices (a, b, c), pick a vertex (say a) and create a vector to the other two vertices (let u = b - a, and v = c - a). The area of the triangle (a, b, c) is one half the length of cross product u x v. <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom1.gif> An alternative method to find the area of triangle is to use Hero's formula. If the lengths of the sides of a triangle are a, b, and c, let s = (a+b+c)/2. The area of the triangle is then sqrt(s* (s-a)*(s-b)*(s-c)) . Are Two Line Segments Parallel? To check if two line segments are parallel, create vectors along each line segment and check to see if their cross product is (almost) zero. Area of polygon The area of a polygon with vertices (x 1, y 1), ..., (x n, y n) is equal to the determinant: 1 | x1 x2 ... xn | --- | | 2 | y1 y2 ... yn | where the determinate is defined to be similar to the 2 by 2 determinant: x1 y2 + x2y3 + ... + xn y1 - y1 x2 - y2x3 - ... - yn x1 Distance from a point to a line The distance from a point P to a line AB is given by the magnitude of the cross product. In particular, d(P,AB) = |(P - A) x (B - A)| / | B - A| . To determine the distance from a point P to the plane defined by A, B, and C, let n = (B - A) x (C - A). The distance is then give by the following equation: d(P,ABC) = (P-A) · n / |n|. Points on a line A point is on a line if the distance from the point to the line is 0. Points on the same side of line This notion only makes sense for two dimensions. To check if points C and D are on the same side of line AB, calculate the z component of (B - A) x (C - A) and (B - A) x (D - A). If the z components have the same sign (i.e., their product is positive), then C and D are on the same side of the line AB. Point on line segment To calculate if a point C is on the line segment AB, check if C is on the line AB. If it is, then check if the length of AB is equal to the sum of the lengths of AC and CB. Point in triangle To check if a point A is in a triangle, find another point B which is within the triangle (the average of the three vertices works well). Then, check if the point A is on the same side of the three lines defined by the edges of the triangle as B. <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom3.gif> Point in convex polygon The same trick works for a convex polygon: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom4.gif> Four (or more) points are coplanar To determine if a collection of points is coplanar, select three points, A, B, and C. Now, if, for any other point D, (B - A) x (C - A)) · (D - A) = ~0, then the collection of points resides in some plane. Two lines intersect Two lines intersect if and only if they are not parallel in two dimensions. In three dimensions, two lines AB and CD intersect if they are not parallel and A, B, C, and D are coplanar. Two line segments intersect In two dimensions, two line segments AB and CD intersect if and only if A and B are on opposite sides of the line CD and C and D are on opposite sides of line AB. <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom5.gif> Note that both of the checks are necessary, as for the last case one of the checks returns true, while the other testifies to the fact that AB and CD do not intersect. In three dimensions, solve following system of equations, where i and j are the unknowns: Ax + (Bx - Ax) i = Cx + (Dx - Cx) j Ay + (By - Ay) i = Cy + (Dy - Cy) j Az + (Bz - Az) i = Cz + (Dz - Cz) j If this system has a solution (i, j), where 0 <= i <= 1 and 0 <= j <= 1, then the line segments intersect at: (Ax + (Bx - Ax)i, Ay + (By - Ay)i, Az + (Bz - Az) i . Point of Intersection of Two Lines For the lines AB and CD in two dimensions, the most straight-forward way to calculate the intersection of them is to solve the system of two equations and two unknowns: Ax + (Bx - Ax)i = Cx + (Dx - Cx) j Ay + (By - Ay)i = Cy + (Dy - Cy) j The point of intersection is: (Ax + (Bx - Ax) i, Ay + (By - Ay) i) In three dimensions, solve the same system of equations as was used to check line intersection, and the point of intersection is: (Ax + (Bx - Ax)i, Ay + (By - Ay)i, Az + (Bz - Az)i) Checking convexity of 2-dimensional polygon To check the convexity of a 2-dimensional polygon, walk the polygon in clock-wise order. For each triplet of consecutive points (A, B, C), calculate the cross product (B - A) x (C - A). If the z component of each of these vectors is positive, the polygon is convex. Point in non-convex polygon To calculate if a point is within a nonconvex polygon, make a ray from that point in a random direction and count the number of times it intersects the polygon. If the ray intersects the polygon at a vertex or along an edge, pick a new direction. Otherwise, the point is within the polygon if and only if the ray intersects the polygon an odd number of times. <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom8.gif> This method also extends to three dimensions (and higher), but the restriction on intersection is that it only intersects at faces and not at either a vertex or an edge. Geometry Methodologies Geometric problems introduce several different tricks that can be used to either reduce the run-time or approximate the solution. Monte Carlo The first geometric trick is based on randomness. Instead of calculating the probability that something occurs, simulate a random event and calculate the fraction of times it occurs. If enough events are simulated, the difference between these two values becomes very small. This can be helpful to determine something like the area of a figure. Instead of calculating the area directly, determine a bounding box, and throw ``darts'' at the box, and estimate what the probability of hitting the figure is. If this is calculated accurately enough, this can give a good estimate of the actual area. The problem with this method is to get a good relative error (error divided by the actual value) requires a large number of successful events. If the probability of the event occurring is very small, the method does not yield good results. Partitioning Partitioning is a method to improve the speed of a geometric algorithm. This entails dividing the plane up into sections (usually by a grid but sometimes into radial sections or some other method), and bucketing the objects into appropriate section(s). When looking for objects within some figure, only those sections which have a non-zero intersection with that figure need to be examined, thereby greatly reducing the cost of the algorithm. This is helpful to determine the set of objects within some distance of a given point (the figure is a circle) or to check for intersections (the figure is a line). <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/geom/geom9.gif> Graph Problems Sometimes what may look like a geometric problem is really a graph problem. Just because the input is points in the plane does not mean it's a geometric algorithm. Example Problems Point Moving Given a set of line segments in the plane, and two points A and B, is it possible to move from A to B without crossing any of the segments? The line segments partition the plane into regions. Determine these regions, and see if A and B reside in the same region. Bicycle Routing Given a collection of non-intersecting buildings along with start and end locations, find the shortest path from A to B that doesn't go through any buildings. Analysis: This is really a graph problem. The nodes are the start and end locations, along with the vertices of the buildings. There are edges between any two nodes such that the line segment between them does not intersect any buildings, with weight equal to the length of the length of the line segments. Once that graph has been calculated, the problem is shortest path. Maximizing Line Intersections Given a collection of segments in the plane, find the greatest number of segments which can by intersected by drawing a single line. Analysis: With a little bit of thought, it is clear that the line segment must pass through two of the vertices of the collection of line segments. Thus, try all pairs of vertices, and calculate the crossing for each. Combining this with partitioning gives an algorithm that runs fairly quickly. Polygon Classification Given a collection of segments defining a polygon, determine if it is simple (no two non-consecutive line segments intersect) and convex.

 

 

 

 

0

 

 

2017-04-15 21:09:08

1

64

N

2

2

0

1340

NOIP_2008.TG1:笨小猴

(wird.pas/c/cpp) 笨小猴的词汇量很小,所以每次做英语选择题的时候都很头疼。但是他找到了一种方法,经试验证明,用这种方法去选择选项的时候选对的几率非常大! 这种方法的具体描述如下:假设maxn是单词中出现次数最多的字母的出现次数,minn是单词中出现次数最少的字母的出现次数,如果maxn-minn是一个质数,那么笨小猴就认为这是个Lucky Word,这样的单词很可能就是正确的答案。

输入文件word.in只有一行,是一个单词,其中只可能出现小写字母,并且长度小于100

输出文件word.out共两行,第一行是一个字符串,假设输入的的单词是Lucky Word,那么输出“Lucky Word”,否则输出“No Answer”; 第二行是一个整数,如果输入单词是Lucky Word,输出maxn-minn的值,否则输出0

【输入输出样例1 error 【输入输出样例2 Olympic

【输入输出样例1 Lucky Word 2 【输入输出样例2 No Answer 0

0

【输入输出样例1解释】 单词error中出现最多的字母r出现了3次,出现次数最少的字母出现了1次,3-1=22是质数。 【输入输出样例2解释】 单词olympic中出现最多的字母i出现了2次,出现次数最少的字母出现了1次,2-1=11不是质数。

NOIP2008

2017-04-15 21:09:08

1

64

N

10

17

0

1341

NOIP_2008.TG2:火柴棒等式

<p> 给你n根火柴棍,你可以拼出多少个形如“A+B=C”的等式?等式中的ABC是用火柴棍拼出的整数(若该数非零,则最高位不能是0)。用火柴棍拼数字0-9的拼法如图所示: </p> <p> <img src="/JudgeOnline/upload/image/20170529/20170529100517_81646.png" alt="" /> </p> <p>  注意: 1. 加号与等号各自需要两根火柴棍 2. 如果A≠B,则A+B=CB+A=C视为不同的等式(ABC>=0 3. n根火柴棍必须全部用上 </p>

输入文件matches.in共一行,又一个整数nn<=24)。

输出文件matches.out共一行,表示能拼成的不同等式的数目。

【输入输出样例1: 14 【输入输出样例2: 18

【输入输出样例1: 2 【输入输出样例2: 9

0

【输入输出样例1解释】 2个等式为0+1=11+0=1。 【输入输出样例2解释】 9个等式为: 0+4=4 0+11=11 1+10=11 2+2=4 2+7=9 4+0=4 7+2=9 10+1=11 11+0=11

 

2017-05-29 10:05:23

1

64

N

6

9

0

1342

NOIP_2008.TG3:传纸条

(wassage.pas/c/cpp) 小渊和小轩是好朋友也是同班同学,他们在一起总有谈不完的话题。一次素质拓展活动中,班上同学安排做成一个mn列的矩阵,而小渊和小轩被安排在矩阵对角线的两端,因此,他们就无法直接交谈了。幸运的是,他们可以通过传纸条来进行交流。纸条要经由许多同学传到对方手里,小渊坐在矩阵的左上角,坐标(1,1),小轩坐在矩阵的右下角,坐标(m,n)。从小渊传到小轩的纸条只可以向下或者向右传递,从小轩传给小渊的纸条只可以向上或者向左传递。 在活动进行中,小渊希望给小轩传递一张纸条,同时希望小轩给他回复。班里每个同学都可以帮他们传递,但只会帮他们一次,也就是说如果此人在小渊递给小轩纸条的时候帮忙,那么在小轩递给小渊的时候就不会再帮忙。反之亦然。 还有一件事情需要注意,全班每个同学愿意帮忙的好感度有高有低(注意:小渊和小轩的好心程度没有定义,输入时用0表示),可以用一个0-100的自然数来表示,数越大表示越好心。小渊和小轩希望尽可能找好心程度高的同学来帮忙传纸条,即找到来回两条传递路径,使得这两条路径上同学的好心程度只和最大。现在,请你帮助小渊和小轩找到这样的两条路径。

输入文件message.in的第一行有2个用空格隔开的整数mn,表示班里有mn列(1<=m,n<=50)。 接下来的m行是一个m*n的矩阵,矩阵中第ij列的整数表示坐在第ij列的学生的好心程度。每行的n个整数之间用空格隔开。

输出文件message.out共一行,包含一个整数,表示来回两条路上参与传递纸条的学生的好心程度之和的最大值。

3 3 0 3 9 2 8 5 5 7 0

34

0

【限制】 30%的数据满足:1<=m,n<=10 100%的数据满足:1<=m,n<=50

NOIP2008

2017-04-15 21:09:08

1

64

N

3

5

0

1343

NOIP_2008.TG4:双栈排序

(twostack.pas/c/cpp) Tom最近在研究一个有趣的排序问题。如图所示,通过2个栈S1S2Tom希望借助以下4种操作实现将输入序列升序排序。 操作a 如果输入序列不为空,将第一个元素压入栈S1 操作b 如果栈S1不为空,将S1栈顶元素弹出至输出序列 操作c 如果输入序列不为空,将第一个元素压入栈S2 操作d 如果栈S2不为空,将S2栈顶元素弹出至输出序列 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/noip/noip2008-4-1.gif> 当然,这样的操作序列有可能有几个,对于上例(1,3,2,4)<a,c,c,b,a,d,d,b>是另外一个可行的操作序列。Tom希望知道其中字典序最小的操作序列是什么。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/noip/noip2008-4-2.gif>

输入文件twostack.in的第一行是一个整数n。 第二行有n个用空格隔开的正整数,构成一个1~n的排列。

输出文件twostack.out共一行,如果输入的排列不是可双栈排序排列,输出数字0;否则输出字典序最小的操作序列,每两个操作之间用空格隔开,行尾没有空格。

【输入样例1: 4 1 3 2 4 【输入样例2: 4 2 3 4 1 【输入样例3: 3 2 3 1

【输出样例1: a b a a b b a b 【输出样例2: 0 【输出样例3: a c a b b d

0

【限制】 30%的数据满足: n<=10 50%的数据满足: n<=50 100%的数据满足: n<=1000

 

2017-04-15 21:09:08

1

64

N

0

1

0

1344

NOIP_2008.PJ1:ISBN号码

isbn.pas/c/cpp) 每一本正式出版的图书都有一个ISBN号码与之对应,ISBN码包括9位数字、1位识别码和3位分隔符,其规定格式如“x-xxx-xxxxx-x”,其中符号“-”是分隔符(键盘上的减号),最后一位是识别码,例如0-670-82162-4就是一个标准的ISBN码。ISBN码的首位数字表示书籍的出版语言,例如0代表英语;第一个分隔符“-”之后的三位数字代表出版社,例如670代表维京出版社;第二个分隔之后的五位数字代表该书在出版社的编号;最后一位为识别码。 识别码的计算方法如下: 首位数字乘以1加上次位数字乘以2……以此类推,用所得的结果mod 11,所得的余数即为识别码,如果余数为10,则识别码为大写字母X。例如ISBN号码0-670-82162-4中的识别码4是这样得到的:对0670821629个数字,从左至右,分别乘以129,再求和,即0×1+6×2+……+2×9=158,然后取158 mod 11的结果4作为识别码。 你的任务是编写程序判断输入的ISBN号码中识别码是否正确,如果正确,则仅输出“Right”;如果错误,则输出你认为是正确的ISBN号码。

输入文件isbn.in只有一行,是一个字符序列,表示一本书的ISBN号码(保证输入符合ISBN号码的格式要求)。

输出文件isbn.out共一行,假如输入的ISBN号码的识别码正确,那么输出“Right”,否则,按照规定的格式,输出正确的ISBN号码(包括分隔符“-”)。

【输入输出样例1: 0-670-82162-4 【输入输出样例2: 0-670-82162-0

【输入输出样例1: Right 【输入输出样例2: 0-670-82162-4

0

 

NOIP_2008.PJ

2017-04-15 21:09:08

1

64

N

1

4

0

1345

NOIP_2008.PJ2:排座椅

seat.pas/c/cpp) 上课的时候总有一些同学和前后左右的人交头接耳,这是令小学班主任十分头疼的一件事情。不过,班主任小雪发现了一些有趣的现象,当同学们的座次确定下来之后,只有有限的D对同学上课时会交头接耳。同学们在教室中坐成了MN列,坐在第i行第j列 的同学的位置是(ij),为了方便同学们进出,在教室中设置了K条横向的通道,L条纵向的通道。于是,聪明的小雪想到了一个办法,或许可以减少上课时学生交头接耳的问题:她打算重新摆放桌椅,改变同学们桌椅间通道的位置,因为如果一条通道隔开了两个会交头接耳的同学,那么他们就不会交头接耳了。 请你帮忙给小雪编写一个程序,给出最好的通道划分方案。在该方案下,上课时交头接耳的学生对数最少。

输入文件seat.in的第一行,有5各用空格隔开的整数,分别是MNKLD2<=NM<=10000<=K<M0<=L<ND<=2000)。 接下来D行,每行有4个用空格隔开的整数,第i行的4个整数XiYiPiQi,表示坐在位置(Xi,Yi)(Pi,Qi)的两个同学会交头接耳(输入保证他们前后相邻或者左右相邻)。 输入数据保证最优方案的唯一性。

输出文件seat.out共两行。 第一行包含K个整数,a1a2……aK,表示第a1行和a1+1行之间、第a2行和第a2+1行之间、、第aK行和第aK+1行之间要开辟通道,其中ai< ai+1,每两个整数之间用空格隔开(行尾没有空格)。 第二行包含L个整数,b1b2……bk,表示第b1列和b1+1列之间、第b2列和第b2+1列之间、、第bL列和第bL+1列之间要开辟通道,其中bi< bi+1,每两个整数之间用空格隔开(行尾没有空格)。

【输入输出样例】 4 5 1 2 3 4 2 4 3 2 3 3 3 2 5 2 4

【输入输出样例】 2 2 4

0

【输入输出样例解释】 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/noip/noip2008-pj-2.GIF> 上图中用符号*+ 标出了3对会交头接耳的学生的位置,图中3条粗线的位置表示通道,图示的通道划分方案是唯一的最佳方案。

 

2017-04-15 21:09:08

1

64

N

0

2

0

1346

NOIP_2008.PJ3:传球游戏

ball.pas/c/cpp) 上体育课的时候,小蛮的老师经常带着同学们一起做游戏。这次,老师带着同学们一起做传球游戏。 游戏规则是这样的:n个同学站成一个圆圈,其中的一个同学手里拿着一个球,当老师吹哨子时开始传球,每个同学可以把球传给自己左右的两个同学中的一个(左右任意),当老师再次吹哨子时,传球停止,此时,拿着球没传出去的那个同学就是败者,要给大家表演一个节目。 聪明的小蛮提出一个有趣的问题:有多少种不同的传球方法可以使得从小蛮手里开始传的球,传了m次以后,又回到小蛮手里。两种传球的方法被视作不同的方法,当且仅当这两种方法中,接到球的同学按接球顺序组成的序列是不同的。比如有3个同学1号、2号、3号,并假设小蛮为1号,球传了3次回到小蛮手里的方式有1->2->3->11->3->2->1,共2种。

输入文件ball.in共一行,有两个用空格隔开的整数nm3<=n<=301<=m<=30)。

输出文件ball.out共一行,有一个整数,表示符合题意的方法数。

3 3

2

0

【限制】 40%的数据满足:3<=n<=301<=m<=20 100%的数据满足:3<=n<=301<=m<=30

 

2017-04-15 21:09:08

1

64

N

2

2

0

1347

NOIP_2008.PJ4:立体图

drawing.pas/c/cpp) 小渊是个聪明的孩子,他经常会给周围的小朋友们讲些自己认为有趣的内容。最近,他准备给小朋友们讲解立体图,请你帮他画出立体图。 小渊有一块面积为m*n的矩形区域,上面有m*n个边长为1的格子,每个格子上堆了一些同样大小的吉姆(积木的长宽高都是1),小渊想请你打印出这些格子的立体图。我们定义每个积木为如下格式,并且不会做任何翻转旋转,只会严格以这一种形式摆放: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/noip/noip2008-pj-4-1.GIF> 每个顶点用1个加号’+’表示,长用3”-“表示,宽用1”/”表示,高用两个”|”表示。字符’+’ ‘-‘’/’ ‘|’ASCII码分别为434547124。字符’.’ASCII46)需要作为背景输出,即立体图里的空白部分需要用’.’代替。立体图的画法如下面的规则: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/noip/noip2008-pj-4-2.GIF> 立体图中,定义位于第(m,1)的格子(即第m行第1列的格子)上面自底向上的第一块积木(即最下面的一块积木)的左下角顶点为整张图最左下角的点。

输入文件drawing.in第一行有用空格隔开的两个整数mn,表示有m*n个格子(1<=mn<=50)。 接下来的m行,是一个m*n的矩阵,每行有n个用空格隔开的整数,其中第i行第j列上的整数表示第i行第j列的格子上摞有多少个积木(1<=每个格子上的积木数<=100)。

输出文件drawing.out中包含题目要求的立体图,是一个KL列的字符矩阵,其中KL表示最少需要KL列才能按规定输出立体图。

3 4 2 2 1 2 2 2 1 1 3 2 1 2

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/noip/noip2008-pj-4-3.GIF>

0

 

 

2017-04-15 21:09:08

1

64

N

0

3

0

1348

【入门题】001比较数的大小

比较三个整数(绝对值都小于等于3000)的大小。

一行,三个整数,中间用一个空格隔开。

一行,由小到大三个整数,中间用一个空格隔开。

1 3 2

1 2 3

0

 

 

2017-04-15 21:09:08

1

64

N

11

20

0

1349

【入门题】002各位数字和

输入一个正整数,分解出正整数中的各位数字,并输出正整数中各位数字之和。

一个多位的正整数

一行,即正整数中各位数字和。

1234

10

0

思考:如何对一个正整数上的各位数字依次进行分割。注意结束条件!

 

2017-04-15 21:09:08

1

64

N

9

15

0

1350

【入门题】003水费

FRACK去美国做交换教师,在新居他拿到了新的收费标准。其中水费的计算让FRACK很恼火。 当地用水紧张,政府为了提倡节约用水,规定用水20立方米以下(20)每吨2美元,如超过20立方米,超过部分每一吨加收1美元资源浪费税。 于是他想请你帮帮忙,替他计算一下这个月要交多少水费。

一行,一个整数n1<=n<=5000

一行,一个整数为要交的水费

50

130

0

 

 

2017-04-15 21:09:08

1

64

N

9

9

0

1351

【入门题】阅读书本

编写程序,输出以下结果: 阅读书本P10: 一、读入半径r 1:输出球体的表面积。 2:输出球体的体积。 阅读书本P19: 二、读入xy 1:输出以e为底,x的对数。 2:输出以10为底,y的对数。 3:输出xy次方。 三、读入角度a(理解pascal中三角函数表达形式,以及角度与弧度间的关系) 1:输出sin函数对应值 2:输出cos函数对应值 3:输出tan函数对应值 4:输出反正切函数对应值 四、读入实数x(理解几个取整函数间的差异,注意关注返回结果类型) 1:输出round(x) 2:输出int(x) 3:输出frac(x) 4:输出trunc(x)

15 12 17 45 13.764

输出每行一个数据,共多行输出。 如果是实数类型,小数点后保留两位。

 

 

0

 

 

2017-04-15 21:09:08

1

64

N

1

1

0

1352

【入门题】005分钱游戏

新年到了,甲、乙、丙三人共同赚了n元钱,他们之前设定了一个分钱方案,如下: (1)先由甲分钱给乙、丙两人,所分给的数与各人已有数相同; (2)接着由乙分给甲、丙,分法同前; (3)再由丙分钱给甲、乙,分法亦同前。 (4)经上述三次分钱之后,每个人的钱数恰好一样多。 求原先各人赚的钱数分别是多少?(假设上述分钱方案无法实施请输出“no solution!”

一行,正整数n(1<=n<=10000)

一行,共3个整数。 (分别表示甲、乙、丙原先各人赚的钱数,整数之间用空格隔开)

24 888

13 7 4 no solution!

0

目的:了解程序在执行过程中,按其顺序步骤,自顶向下,依次执行来完成!

 

2017-04-15 21:09:08

1

64

N

0

3

0

1353

【入门题】006相同的后三位

对于给定的p(100<=p<=9999),编写程序求最小正整数m,n(0nm)为何值时,p^mp^n的最后三位数字相同。

一行,p

一行,最小的mn,mn用空格隔开。如有多组,输出最小的m那组。

100

3 2

0

 

 

2017-04-15 21:09:08

1

64

N

2

3

0

1354

【入门题】鸡兔同笼

鸡兔同笼自古以来人们一直津津乐道,比如: 问题1:某车棚存有自行车和三轮车共65辆,它们的轮子数合计为150个。求该棚内存有的自行车和三轮车各是多少辆? 问题2:有鸡兔同笼,头30,脚 90,究竟笼中的鸡和兔各有多少只?

输入数据分两行: 第一行,共两个正整数:mn,其中m表示自行车和三轮车总数;n表示轮子数之和。 第二行,共两个正整数:ab,其中a表示头数和;b表示脚数和。

输出数据共两行: 每行共两个正整数,用空隔隔开。

65 150 30 90

 

0

 

 

2017-04-15 21:09:08

1

64

N

0

4

0

1355

【入门题】008约的个数

求一个自然数n(1<=n<=10^9)约数的个数,1和它本身。

一行,自然数n

一行,约数的个数。

6

4

0

 

 

2017-04-15 21:09:08

1

64

N

5

5

0

1356

【入门题】009Fibonacci数列问题

Fibonacci数列问题:数列的头两个数分别为0,1,从第三个数开始,每个数皆为它的前面两个数之和,:0,1,1,2,3,5,…,输出该数列的第n个数。

一行,n(1<=n<=45)

一行,n个数

5

3

0

 

 

2017-04-15 21:09:08

1

64

N

2

3

0

1357

【入门题】010换币方法

n张一元钞票换成一分、二分和五分的硬币(每种至少一枚),问有多少种换法?

一行,自然数n(1<=n<=80)

一行,多少不同换法

1

461

0

 

 

2017-04-15 21:09:08

1

64

N

3

4

0

1358

【入门题】011立方数的分解

任何一个正整数的立方都可以写成一串奇数之和,这就是著名的尼科梅彻斯定理。 1^3=1 2^3=3+5=8 3^3=7+9+11=27 4^3=13+15+17+19=64 给出n,n^3是哪n个连续奇数之和?

一行,n(1<=n<=10000)

连续奇数相加等于立方的算式,例如 当n=1,输出:1=1 n=3,输出:7+9+11=27

3

7+9+11=27

0

 

 

2017-04-15 21:09:08

1

64

N

3

3

0

1359

【入门题】012级数求和

已知:Sn=1+1/2+1/3+…+1/n。显然对于任意一个数K,当n.足够大的时候,Sn大于K。 现给出一个整数K(1≤K≤15),要求计算出一个最小的n,使得Sn>K

一行,一个整数K

一行,一个整数n

1

2

0

 

 

2017-04-15 21:09:08

1

64

N

3

3

0

1360

【入门题】013三数相邻

给出一行中的n(6<=n<=200)个正整数(小于30000),找出相邻的三个数为一组,求其和。你的任务是找出两组,使它们的差值最大。 说明:找出的这两组中的六个数所在位置完全不同。

第一行为n,第二行为n个数,各个数之间用一个空格隔开。

一行,最大的差值。

7 1 2 3 4 5 6 7

12

0

 

 

2017-04-15 21:09:08

1

64

N

2

3

0

1361

【入门题】014数字换位

给出一个自然数n(1<=n<=10^9),任意交换各个数位上的数字,得到另一个自然数m,在保持位数不变的情况下,求最小的m

一行,n

一行,m

2014

1024

0

 

 

2017-04-15 21:09:08

1

64

N

3

3

0

1362

【入门题】015简易算式

我们用"+"表示加号,"-"表示减号,"*"表示乘号,对于整数a,b(|a|<=32767,|b|<=32767),有下面的简单算式: a+b a-b a*b 求计算的结果。

一行,只有两个整数参加运算的算式

一行,计算结果

12*12

144

0

 

 

2017-04-15 21:09:08

1

64

N

3

3

0

1363

【入门题】016三角形的个数

给出n(3<=n<=100)条长度完全不同的线段,从中任选3,问能组成多少个不同的三角形?

第一行,线段的条数n; 第二行,n个数,n条线段的长度(不超过10000),各个数之间用一个空格隔开。

一行,组成三角形的个数

4 1 2 3 4

1

0

 

 

2017-04-15 21:09:08

1

64

N

3

3

0

1364

【入门题】017哥德巴赫猜想

任一个充分大的偶数N(4<=N<=5*105),可以用两个素数之和表示。例如: 4=2+2 6=3+3 8=3+5 98=19+79 而对于N我们可以表示为多组的两个素数之和,例如:10=3+7,10=5+5。我们规定类似“10=3+7”“10=7+3”是同一组。

一行,一个充分大的偶数N

可以分解成多少不同的组?

10

2

0

 

 

2017-04-15 21:09:08

1

64

N

3

3

0

1365

【入门题】018成绩处理

给出n(1<=n<200)个同学m(1<=m<=5)科的考试成绩,按总分找出前十名是哪些同学。我们规定:总分相同名次相同,且占用后面的名次,例如:第2名有两个同学,那么将没有第3名,后面的同学将从第4名算起。

第一行为nm,下面n行为每个同学的成绩描述: 每行有m+1个数,其中第一个数为学号(小于等于200),后面为各科成绩,中间用一个空格隔开。

一行,成绩名次在前10的同学学号,不足10名全部输出。当第10名有多个同学时,输出有可能超过10名同学的学号。同名次按学号由小到大输出。输出的各个学号之间用一个空格隔开。

17 2 1 7 13 2 18 54 3 47 91 4 65 86 5 44 48 6 92 88 7 80 36 8 76 68 9 54 21 10 65 11 11 61 69 12 78 32 13 0 81 14 93 32 15 42 97 16 28 9 17 65 55

6 4 8 15 3 11 14 17 7 12

0

 

 

2017-04-15 21:09:08

1

64

N

1

3

0

1366

【入门题】019小辉的决心

小辉同学是一位非常热爱学习的好同学,但英语成绩总不理想,经常比他的同桌低二三十分。他苦读英语,渴望在半期英语考试中取得高分,他的梦想能实现吗?我们拭目以待。 英语试卷上共有n道大题,每道大题有5个小题,每道小题都有A,B,C,D四个选项。每小题2分。你作为他的同桌兼精神领袖,请在考试后得到标准答案后,告诉他他能得多少分,以及你会比他高多少分。 满分是不定的,每次需要自行计算(事实表明,你的答案每次都与标准答案完全相同)。

第一行一个整数n(1<=n<=10),代表有n个大题,以下2n+1: 每行前五个是他的答案,接下来5个是你的标准答案,中间用空格格开。

两行,第一行是他的得分,第二行是你比他多的分数。

4 ABCDA DACDA DABDA CDABC BABDA CCCCC CCABD BBCCA

6 34

0

 

 

2017-04-15 21:09:08

1

64

N

3

5

0

1367

【入门题】020猴子选大王

n(1<=n<=100)个猴子需要选出一个大王,选大王的规则是: 先围成一圈,用一个可以随机产生正整数112的骰子,产生一个数m(1<=m<=12),从编号为1的猴子开始报数,报到m的出局,这样依次再从后缀位置开始,从剩下的报数,到m者出局......这样剩下的最后一只猴子就是大王。 用猴子的编号来描述,猴子所围圈的构成结构是:1,2,3,4...,n-2,n-1,n,1,2,3,...

第一行nm,从第2行到n+1行依次是编号1n猴子的名字。

大王的名字。

18 4 CRKTDPGH H VTM RQISRRDQ ZOYILCESA GXFOWKZDKO DDXQ DNTMZHB VDPBK JUJD GGE O BX WFX V SNXQBNJUXX IRBFKU ZJPDJM

VDPBK

0

 

 

2017-04-15 21:09:08

1

64

N

3

3

0

1368

【入门题】021点名

刚来学校信息学奥赛的第一天,作为教练的吴老师当然要点一下名,以防某些懒惰的学生逃课,吴老师手上有一张名单,老师报名字后,在的人叫一声到。这样老师就能知道哪些人不在。

第一行包含两个整数n , m 分别表示一共的人数和出席的人数( n <= 1000 , m <= 1000 ),接下来n行每行一个字符串,长度小于20,表示名单上的姓名。再接下来m行每行一个字符串,表示出席人的姓名。

以下k行每行包含一个字符串,串表示不在的人的姓名,顺序按照名单上原来的顺序。

8 3 Liufei Wupeifeng Fuyibo Zhaoyang R3 Mazi Mcjdx yuchun Wupeifeng yuchun fuyibo

Liufei Zhaoyang R3 Mazi Mcjdx

0

 

 

2017-04-15 21:09:08

1

64

N

0

2

0

1369

【入门题】022学号安排

每个人在学校都会有一个学号,信息学奥赛也不例外。出于对学生自尊心的保护,决定不按成绩好坏来给一个学生授予学号,而是按姓名的拼音的字典序授予学号。

第一行包含一个整数n,表示一共有n个人(n<=100),接下来n行每行一个字符串,表示每个人的姓名(不超过20个字符)。

每行一个按原来姓名的先后给出相应的学号

3 Bbb Aaa Ccc

2 1 3

0

 

 

2017-04-15 21:09:08

1

64

N

2

2

0

1370

【入门题】023丢失的号码

ZZRZ的手机号码(11位)弄掉了,他只记得号码的前几位数,由于情况紧急,ZZ只好在记得的号码后面添加数字一个一个地试(每次加1),求试多少次可以试出来。

两行,第一行:ZZ记得的号码N(位数在211之间,211);第二行:ZR的手机号码;

一行,试的次数S;如果ZZ记错了号码,则输出No

1234567891 12345678911

2

0

 

 

2017-04-15 21:09:08

1

64

N

1

2

0

1371

【入门题】024找学号

给出n(1<=n<=200000)个按字典序排好序的同学姓名(姓名不超过20个字符),这样我们就用自然数列:1,2,3,4,..,n-1,n来对应他们的学号。当知道某个同学的姓名时,你能找出他们的学号吗?

第一行为n,下面2n+1行为排好序的n个同学的姓名;接下来一行为一个数m(1<=m<=100),表示需要找出学号的同学个数;再接下来为m行是需要找出学号的同学姓名。

m行,对应m个同学的学号。

10 abcd abcdd abce abcf abcg abch abci abcj abcx abcy 3 abcx abcdd abcg

9 2 5

0

 

 

2017-04-15 21:09:08

1

64

N

1

2

0

1372

【入门题】025求两数的和(II)

求两个给定进制正整数ab的和。其中ab的位数小于254,进制范围在216

三行,第一行进制,后面两行是ab

ab的和。

2 111 1101

10100

0

 

 

2017-04-15 21:09:08

1

64

N

0

2

0

1373

【入门题】026两个数的和(I)

求两个自然数ab的和。其中ab的位数小于254

两行,自然数ab

一行,ab的和。

12 13

25

0

 

 

2017-04-15 21:09:08

1

64

N

4

4

0

1374

【入门题】027求两个数的乘积

求两个自然数ab的乘积。ab的位数都小于254

两行,自然数ab

一行,ab的积。

12 13

156

0

 

 

2017-04-15 21:09:08

1

64

N

3

4

0

1375

【入门题】028求差

输入两个非负m2<=m<=16)进制数(位数小于200,且第一个数不小于第二个数),计算它们的差。

共三行,第一行为m,后面两行是被减数与减数

一行,差

2 101 1

100

0

 

 

2017-04-15 21:09:08

1

64

N

2

2

0

1376

【入门题】029狐狸追兔子

围绕着山顶有m个洞(m<=100),一只狐狸和一只兔子住在各自的洞里。狐狸总想吃掉兔子。一天,兔子对狐狸说:你想吃我有一个条件,先把洞从1~m编上号,你从m号洞出发,先到一号洞找我;第二次隔1个洞找我,第三次隔2个洞找我,以后依次类推,次数不限。若能找到我,你就可以饱餐一顿。不过在没有找我以前不能停下来。狐狸满口答应就开始找了,它从早到晚进了n次洞(1<=n<=1000),累得昏了过去也没有找到兔子。请问,兔子躲在几号洞里?

一行,洞的个数,狐狸进洞的次数

一行,兔子躲的洞的号数,由小到大输出,各数中间用空格隔开

10 2

2 4 5 6 7 8 9 10

0

 

 

2017-04-15 21:09:08

1

64

N

0

3

0

1377

【入门题】030求递增和递减序列个数

给定一串整数数列(数列中数的绝对值均小于32767),数列个数为nn<=100),求出所有的递增和递减子序的数目,如数列: 7269835210可以分为(72),(269),(983),(35),(5215个子序列。我们称为2935为转折元素。答案就是5.

两行,第一行 n 第二行 有n个用一个空格相隔的整数

一行,递增和递减子序的数目

10 7 2 6 6 9 8 3 5 2 1

6

0

 

 

2017-04-15 21:09:08

1

64

N

0

1

0

1378

【入门题】031求马鞍数坐标

求一个5 X 5矩阵中的马鞍数,输出它的位置。所谓马鞍数,是指在行上最小而在列上最大的数,其中矩阵中的数最大不超过32767

任意一个55列的矩阵

马鞍数的数组下标值,若有多个,换行输出

9 5 4 7 8 3 4 3 2 1 7 6 5 8 9 6 3 2 9 0 1 2 1 4 8

3 3

0

 

 

2017-04-15 21:09:08

1

64

N

0

2

0

1379

【入门题】032蛇形矩阵

小明玩一个数字游戏,取个nn列数字矩阵(其中n不超过100),数字的填补方法为:从1开始以顺时针方向绕行,逐圈扩大,直到nn列填满数字,请输出该nn列正方形矩阵以及其的对角线数字之和.

n(即nn列);输出格式:每个数据输出显示时设置场宽为3

总共n+1行,前n行为组成的矩阵,最后一行为对角线数字之和。

3

7 8 9 6 1 2 5 4 3 25

0

 

 

2017-04-15 21:09:08

1

64

N

1

3

0

1380

【入门题】005分钱游戏——升级版

题目一: 甲、乙、丙三人分别有磁带364864盒。先由甲把自己的磁带平均分为三份,分给乙、丙各一份,自己留下一份;接着是乙,最后是丙,都按甲的方法处理。编程输出甲、乙、丙在上述过程中各人的磁带数分别是多少? (输出所有的中间结果) 题目二: 五位好朋友相聚。第一位朋友带来了很多糖块赠送给各位朋友,使每人的糖块在各自原有的基础上翻了一倍;接着第二位好友也同样向每人赠送糖块,他同样使每人的糖块在各人已有的数量上翻了一倍;第三、第四、第五位好友都照此办理。经过这样的赠送之后,每人的糖块恰好都为32块。问各位好友原先的糖块数分别是多少?

无输入数据

先输出题目一、再输出题目二。

 

 

0

 

 

2017-04-15 21:09:08

1

64

N

1

1

0

1381

【入门题】三角形判定

输入三个正整数,若能用这三个数作为边长组成三角形,输出Yes,同时计算并输出该三角形的面积, 如果不能构成三角形则输出No (组成三角形的条件为:???,不会不知道吧,不知道回小学母校问数学老师哦!)

一行,输入三个正整数。

能构成三角形分两行输出:一行输出Yes,另一行输出该三角形的面积; 不能构成三角形,则输出No

3 4 5

Yes 6.00

0

 

 

2017-04-15 21:09:08

1

64

N

1

4

0

1382

【入门题】四位数重排

输入一个4位数,(绝对值小于3000),重新排列该4位数上的各位数字,最后将其输出,要求输出的4位数构成的数尽可能的大! (该数的正负在排列过程中不会改变!)

输入一个整数n,除符号位外,由4位数字构成。

输出由这4位数字重新组合,构成的最大4位数。 (输出过程中,要求考虑到该整数的正负情况。)

2345 -2397

5432 -2379

0

 

 

2017-04-15 21:09:08

1

64

N

0

3

0

1383

【入门题】4.1_P87

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_1.jpg>

 

分多行输出。 每行数据内容包含xsin(x)cos(x)tan(x),数据之间用空格隔开,实型数据小数点后保留两位。

 

(前三行样例输出如下:) 0 0.00 1.00 0.00 10 0.17 0.98 0.18 20 0.34 0.94 0.36 ……………………

0

 

 

2017-04-15 21:09:08

1

64

N

1

1

0

1384

【入门题】4.2_P87

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_2.jpg>

 

分多行输出。(每行数据多个,数据间用空隔隔开,实型数据小数点后保留两位)

 

前三行样例输出: 1.00 1.00 1.00 2.72 0.00 1.10 1.21 1.05 3.00 0.10 1.20 1.44 1.10 3.32 0.18 ………………………………

0

思考: (1)以10为底,x的对数如何用pascal语句表达。 (2xy次方用pascal语句如何表达。

 

2017-04-15 21:09:08

1

64

N

2

2

0

1385

【入门题】4.3_P87

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_3.jpg>

一行,共10个整数。

一行,共4个数,依次为:它们的和、积、平方和及和的平方。

2 3 4 5 6 7 8 9 0 1

45 0 285 2025

0

注意:在程序设计过程中,通常有必要对数据可能的取范围作出预测,这一点很重要! Pascal定义了的整数类型,如下: 类型 取值范围 格式 (占字节数) Shortint(短整型) 【-128..127】 带符号 8位 【1 Integer (整型) 【-32768..32767 】 带符号16位 【2 Longint(长整型) 【-2147483648..2147483647 】 带符号32位 【4 Int64 -9223372036854775808 .. 9223372036854775807=2^63 -1】带符号64位 【8 ………… Byte (字节型) 【0..255】 无符号8位 【1 Word  (字型) 【0..65535】 无符号16位 【2 Dword(双字型) 【0..4294967295】 无符号32位 【4 Qword 0 .. 18446744073709551615=2^64 -1】 无符号64位 【8

 

2017-04-15 21:09:08

1

64

N

3

3

0

1386

【入门题】4.4_P87

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_4.jpg>

 

共计35行,逐行依次输出1!,2!,3!,4!,……35

 

1!=1 2!=2 3!=6 4!=24 5!=120 6!=720 7!=5040 8!=40320 9!=362880 10!=3628800 ………………

0

类型 取值范围 有效数字(占字节数) Real 2.9×10^-39~1.7×10^38 7~8位【6 Single 1.5×10^-45~3.4×10^38 11~12位【4 Double 5.0×10^-324~1.7×10^308 15~16位【8 Extended 3.4×10^-4932~1.1×10^4932 19~20位【10 Comp -2^63+1~2^38-1-9.2×10^18~9.2×10^18 19~20位【8

 

2017-04-15 21:09:08

1

64

N

1

1

0

1387

【入门题】4.5_P87

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_5.jpg>

 

16行,逐行输出n=0123……15,时的不同取值。 1.每行包含内容为:n2^n2^-n;数据中间用空格隔开。 2.实数结果类型小数点后保留10位输出。

 

0 1 1.0000000000 1 2 0.5000000000 2 4 0.2500000000 3 8 0.1250000000 ……………………

0

 

 

2017-04-15 21:09:08

1

64

N

2

2

0

1388

【入门题】4.6_P87

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_6.jpg>

 

输出圆周率值,小数点后保留10位。

 

 

0

 

 

2017-04-15 21:09:08

1

64

N

2

2

0

1389

【入门题】4.7_P87

输入多个数据(个数不确定),统计其中正、负和零的个数。

 

 

2 3 3 4 0 0 -2 0 -4

4 2 3

0

先简单地了解一下文件操作! 注意:eofseekeof在本题中的差异! while not eof(input) do begin read(m); end; 2 3 0 0 3 -1 -3 1 3 0 0 0 1 2 4 5 其中零的个数输出为:6 while not seekeof(input) do begin read(m); end; 其中零的个数输出为:5 函数说明: eolnendoflineeofendoffile

 

2017-04-15 21:09:08

1

64

N

1

2

0

1390

【入门题】4.8_P87

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_8.jpg>

从键盘读入一个正整数n,表示所求的范围为:1……n。(其余条件保持不变)

输出时数据间用空格隔开,同样每行至多为10个数据。 在输出数据最下方,另起一行输出一个数据表示:总共输出了多少个元素。

50

23 1

0

 

 

2017-04-15 21:09:08

1

64

N

0

3

0

1391

【入门题】4.9_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_9.jpg>

读入一个整数n:表示所求范围为(1——n)。

输出时每行至多10个数据,数据之间用空格隔开。 在所有数据最下方,另起一行输出一个数据表示:以上输出数据元素的总个数。

50

15 45 2

0

 

 

2017-04-15 21:09:08

1

64

N

0

1

0

1392

【入门题】4.10_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_10.jpg>

 

数据元素间用空格隔开。

 

 

0

关于divmod运算两点说明: (1)了解其运算的优先级别,按优先级别排一排顺序:divmod * /+-。 (2)真正掌握moddiv运算的实质规律。 请认真阅读,并写出结果。 writeln(33 mod 7 div 5); writeln(33 mod (7 div 5)); writeln(33 mod 7); writeln(-33 mod 7); writeln(33 mod -7); writeln(-33 mod -7); writeln(33 div 7); writeln(-33 div 7); writeln(33 div -7); writeln(-33 div -7);

 

2017-04-15 21:09:08

1

64

N

2

2

0

1393

【入门题】4.11_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_11.jpg>

读入一个数据n

若输出有多个数据,则数据元素间用空格隔开。

1000

5 6 25

0

 

 

2017-04-15 21:09:08

1

64

N

0

1

0

1394

【入门题】4.12_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_12.jpg>

 

请依次输出数列a0a1a2……a50(数据间用空格隔开,每行至多5个数据元素。) 用心感受一下数据增长变化的加速度。

 

0 1 1 3 6 13 28 60 129 277 595 1278 2745 5896 12664 ……………………………………

0

 

 

2017-04-15 21:09:08

1

64

N

1

1

0

1395

【入门题】4.13_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_13.jpg>

 

依次输出20个整数中的最大值,最小值,平均值,(数据间用空格隔开,平均值小数点后保留两位)

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0

9 0 4.50

0

考虑问题时要注意一些不起眼的细节,这也是一种好的编程习惯!

 

2017-04-15 21:09:08

1

64

N

2

2

0

1396

【入门题】4.14_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_14.jpg>

 

输出处理:将实型数据放大35倍后,四舍五入取整后右移40单位。以“*”做描点标示。 (以换行当作单位宽度)即可将x轴垂直向下处理。 示例:roundm*35+40

 

* * * * * * * * * * * * * * * * * * * * * * * * …… …… …… …… …… …… 参考: 1.2300000000000000E+0002 1.2300000000000000E+0002 -1.2300000000000000E+0002 -1.2300000000000000E+0002 6.5400000000000000E-0001 4.5600000000000000E-0001 -6.5400000000000000E-0001 -4.5600000000000000E-0001 124 123 -124 -123 123 123 -123 -123

0

关于数据整数与小数部分处理的几个函数: (1int(x) x的整数部分(不舍入,函数值为实型); (2frac(x)x的小数部分; (3round(x) x的四舍五入整数; (4trunc(x) x的整数部分(截掉小数部分,结果为整型); 请写出下列程序输出结果: 要求: (1)注意结果返回类型 (2)掌握各个函数具体功能实质 write(int(123.654)); write(' ',int(123.456)); write(' ',int(-123.654)); writeln(' ',int(-123.456)); write(frac(123.654)); write(' ',frac(123.456)); write(' ',frac(-123.654)); writeln(' ',frac(-123.456)); write(' ',round(123.654)); write(' ',round(123.456)); write(' ',round(-123.654)); writeln(' ',round(-123.456)); write(trunc(123.654)); write(' ',trunc(123.456)); write(' ',trunc(-123.654)); writeln(' ',trunc(-123.456));

 

2017-04-15 21:09:09

1

64

N

1

1

0

1397

【入门题】4.15_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_15.jpg>

 

输出处理:将实型数据放大35倍后,四舍五入取整后右移40单位。以“*”“#”做描点标示。 (其中sin函数描点使用“*”cos函数描点使用“#”) (以换行当作单位宽度)即可将x轴垂直向下处理。 示例:roundm*35+40

 

* # * # * # * # * # # * # * # * # * # * # * # * # * # * # * # * # * # * # * # * # * # * # * * # * # * # * # * # * # * # * # * # * # ……… ……… ……… ……… ……… ………

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1398

【入门题】RP导论(Oier成长必读圣经)

建议:初级选手不用读,因为大部分内容没法真正读懂。 再次建议:我校OI竞赛同学阅读时间可推迟至高一第二学期后半阶段。 RP导论(来自"NOCOW") 这篇文章可以证实是由NOCOW用户原创,不存在任何版权争议。 本文作者同意以GNU FDLCC-by-saGNU LGPL(如果适用)三种版权发布此文章(不包括翻译文章中属于原始所有者的部分版权)。 如果你修改了这篇文章并且不同意用GNU FDL以外的版权发布,可以换一个版权模板或者移除此模板。 RP,是人品的缩写,在民间广为流传,被不少人视作真理,也有很多人将之视作迷信。 目录 • 1 ——为什么要写RP导论 • 2 RP的定义与形成 o 2.1 RP的概念与意义 o 2.2 RP的形成 • 3 RP的影响与利弊 o 3.1 RP的不利影响 o 3.2 RP的有利影响 o 3.3 小结RP的利弊 • 4 RP的估测与评价 o 4.1 RP的单位系统 o 4.2 RP的估测方法 o 4.3 RP的持续性浅析 o 4.4 如何评价日常行为与RP的关系 • 5 RP的变化与操控 o 5.1 RP的几大定律 § 5.1.1 RP第一定律 § 5.1.2 RP第二定律 § 5.1.3 RP第三定律 § 5.1.4 推论 o 5.2 RP的变化因素 o 5.3 人为调节RP的技巧与方法 • 6 RP的奇律 • 7 RP故事 • 8 RP学派 序——为什么要写RP导论 真的很早就了解到RP在信息学竞赛中举足轻重的作用了,加上前两天由于爆RP考试爆零,星际被虐,交OJ莫名其妙unac……一切的一切,让我不得不把RP的理论系统篆写于书,以供参考,防止大家重蹈我的覆辙。 众所周知,在信息学竞赛中,除去算法数据结构使用,程序编写调试能力之外,排在第三的对比赛有至关重要作用的便是RP了,RP高的人即使不知道算法也能用随机,贪心,搜索等RP算法得到无比多的RP分数;相反,没RP的人,有时知道正确算法也写出了正确程序,也往往会因为缺少RP而无法得分。这样看来,系统研究RP的积累与损失,以及量化地分析它对比赛的结果的影响就显得十分重要了。 但是,目前国内外系统研究RP的论文和书籍都还很缺乏,也有很多优秀的OIer认识到了RP的重要性,但又因种种原因没能从事RP方面的研究,导致很多OIer因为对RP不了解而出现发挥失常,与奖牌失之交臂,为了让这种悲剧不再发生,我们有必要仔细研究RP了。 注《RP导论》原始版本由洪骥发布,后由西南OI剑派CDQZ分部弟子联合编辑至今,欢迎天下同道前来编辑。 • OIBH有一篇《RP艺术与信息学竞赛》,欢迎观看. RP的定义与形成 RP的概念与意义 RP是大家耳熟能详的一个词汇和概念,改革开放以来,随着市场经济的深入,竞争日益激烈,大家都在寻找在各自领域取胜的有效方法,人们考虑各种因素来提高自己成功的概率。 在这样的大背景下,便自然而然地产生了RP的概念,起初这个概念还是依附在其他因素上的一个附属品,但是当人们真正认识到它的影响时,才发现它是一个独立的体系。由于各地各文献内容对RP的定义都很模糊,也不够统一,因此笔者在此一学术的角度,客观的方式 给出RP的严格定义: RP:在一定时间和空间范围内独立于可见因素之外以不确定方式左右客观事物变化方式甚至规律的无形物质。 一直以来,大家觉得RP过于飘渺,不愿意研究它,这其实是由于没有真正意识到RP在客观世界物质变化规律中的重要意义,由于客观世界矛盾的普遍性存在,导致RP因素在事物发展变化的各个角落都发挥着不可忽略的决策性作用,一般来说,RP的意义主要有以下几点: 1.对客观世界的平衡作用 物质世界总是趋于平衡的,无论是能量|物质守衡定律,还是热力学第一,第二定律,都从侧面支持这一结论。但是在事物的各个方面个体之间不可能完全平衡,而又不一定能在不多的可见主观因素中使个体之间实现平衡(这正如 背包-----双塔问题 不一定有解一样),但是只要有了RP,就能很方便地对客观世界进行微调,使世界不失和谐。 2.对主观行为的威慑作用 所谓善有善报,恶有恶报,但是很难说服一个即将做不厚道事情的人让他停止,因为我们不能具体说出他的不厚道行为到底为什么会对他自己也有害,但是现在有了最强有力的威慑武器:RP!当他做不厚道事情的时候,最需要考虑的不是别的,正是自己的RP银行。 3.对主观行为的激励作用 与第二条相类似,RP的存在可以很大程度上激励人做积累RP的厚道事情,这里不再赘述。 RP的形成 总的来说,RP的形成是多方面因素综合形象后的结果。对于RP形成的决定性因素,学术界一直没有公认的理论,目前比较被人接受的说法是: RP的形成与平时做事的厚道程度的二次方根成正比,但是也有人质疑这种说法,原因是有时一个很厚道的人也会莫名其妙没RP,典型的案例是发生在中国四川一个学校的一个叫hj的人,平时很厚道,但是也遇到了没RP的情况,虽然这很罕见,但是不得不让人思考,因此,有学者认为:在一定时间和客观条件下,RP值与该人做事厚道程度之和的正弦函数有关,因此呈现出很让人费解的波动性图象,但是这种理论因为缺乏实验支持,目前还没有在学术界占领主导地位,但是笔者认为,这种理论应该更贴近RP形成机理的真实情况。(最新研究表明,波动正是RP趋于平衡的必然结果,由于一个人的RP太高的情况下,失去RP相对容易,所以会从波峰逐渐跌入波谷,反之亦然) 另外,RP的形成是有阶段性的,也就是说,有时候RP的变化并不是立竿见影的,但是RP升降因素的积累是不会停止的,在某个时期可能表现地不明显,但是宏观上的RP积累是一定的,这也就形成了RP的波动性改变,所以大家在某个RP低迷的时期也不应该停止对RP的积累。(就像力改变的是加速度,而不会对当前的速度有立竿见影的影响,不过长期的影响是深远而持久的) 另外客观世界满足一个基本定律————RP守衡定律,即RP不会凭空创生,也不会凭空湮灭,只会从一个人身上转移到另一个人身上,RP转移有以下两种方式: (1)虐与被虐。 泡mmmm被泡或者被mm泡。 这两条都很好理解,比如,某人星际被虐了,他的RP会有上升的倾向,另外,抢别人mm的人的RP会异常迅速地下降,所以大家一定要厚道。被mm泡人品会怎么样暂时还没有可以参考的案例…… mm泡一般人品会下降,少数会上升 (2RP的影响与利弊 RP的不利影响 对于RP不足带来的不利影响,想必读者已经有了不少体会了,为了系统介绍,这里将不利影响列举一些例子如下: 1、考试爆0(考挂,发挥失常等) 2、泡mm失败(被无视,被抢夺等) 3、自行车胎被扎(汽车,电瓶车) 4、物品频繁损坏(如T43等) 5、星际被虐(连续被虐很多局根据叠加原则将会出现更深远的影响) 6、误机(堵车,迷路等) 以上每一条虽然是RP不足带来的不利影响,但是客观上又可以积累RP,这也正体现了客观世界与RP的辨证关系。 从宏观上讲,上述事情也许并非全是坏事,像(3),(4)两条在扩大内需,刺激经济增长方面也是有积极作用的,但是本文讨论的主观色彩较重,对一些过于YY的东西不做讨论。 关于RP带来的麻烦的解决方法,学术界一直争论不休,企图认为改变RP变化趋势的想法,已经被实践证明是NPC,想预测RP的发展方向,也被论证是不可解问题。 那么,面对RP带来的不利影响,我们真的就束手无策了 吗?非也!我们有解决NP类问题的有力武器:星际!!!! 在RP不好的时候,开High—AI调两家神族,遭电脑虐几盘,RP指数相信会有很大概率要++的,虽然这仍然是个部分算法,但是事实证明是很有效的,已经不亚于cqf的(sei)机贪心了…… 此外,另有极端人士为了平衡自己的RP,在关键时刻向别人赠送人民币,虽然被证明实际效果甚微,但是由于接受方会损失大量RP,所以这种行为也被认为是极度危险和边缘的。对于此损人不利己的行为,将会在以后对自己的RP走向产生不利影响。 古时另有各种迷信活动来祈求获得RP,经证明一些行为是十分有效的,但是尚没有任何科学理论可以他们的成功,其中最著名的历史事件为诸葛亮借东风,这是以神秘的法事活动来获得RP成功的典型例子,不但说明了我国的RP研究在很早的时候就有开展,并且代表了当时的RP学说已经发展到相当先进的阶段,后来由于战乱和历史原因,RP学逐渐没落和淡出国人的视野,在近代才又被重新提出和加以研究,但想恢复当年的水平还任重而道远。 RP的有利影响 对于希望利用RP以追求更高品质生活的读者来说,RP的有利影响也是应该了解的重要问题之一。关于RP的有利影响,对于大部分本人读者来说,不外乎下面两个方面: (1)考试获得理想的分数 (2)泡MM获得阶段性成果 总结起来便是工作方面和生活方面,从中可以看出,RP对于生产生活的各个方面如果合理加以利用都可以达到相当大的有利效果。所以,天下之大,RP独尊,若存在一种方式,可以让一个人长期保有相当量的RP,那么此人便可以独步天下,无人能当,足以可见RP的威力。(也有学者认为本情况是不可能成为现实的,不过并没有合理的证明)不过关于高RP独步天下的例子,笔者实在难以获得,这也从侧面反映了RP易失难获的性质,从而说明了大自然趋于平衡的典型特征。 *小结RP的利弊* 一、RP的估测与评价 RP的单位系统 RP单位 德,符号De. Rp感应系数单位 品,符号Pn. Rp场强度单位 运,符号 Yn. Rp常量单位 米每品,符号 m/Pn; 定义:De是等量与一次雷锋叔叔帮战友看倒车的RP的十分之一。 其余量,随此计算。 RP的估测方法 刘汝佳大牛曾在WC2008之前某一天深夜灵感爆发,在国家集训队群中公布了自己对RP的研究:RP和请客次数乘以时间的三次方有一定关系(来源请求?) ________________________________________ 以下是来自Azrle的个人见解: Erp的变化量大小插入数学公式Erp = ( | w  f | + 1) / Pw表示期待事件发生的次数,如果不想它发生一次那么w=-1,超级不希望它发生w=-100000f是事件的频数,P是事件的概率) 此公式可用来计算瞬间转移的RP值,例如:一个人中了500W,中奖的概率是1/1000000,想这一次中奖,那么,Erp=1000000(z是他有多期待在家中500W),也就是说,他瞬间损失了这么多RP势能。如果你不去想,即w=0,那么将会损失更多RP(可以这么理解,你无所谓的事情都发生了,那你肯定要多损失点RP啦)。再例如:帮老奶奶过街,因为碰到这样的情况概率不大(也就是说机会难得啊,如果是一般的让座估计就没这么多RP赚了),所以得到的Erp也就大咯。 ________________________________________ Lord Beyond Yahweh 的研究,Rp是一个标量场。每个精神体会在其周围空间激起RP场,其强度随距离的增加呈一次方反比递减。 d(RP)/d(P=Lrp*RP/x Lrp,为Rp常量,在不同文化环境内,有不同的Lrp值。 每个精神体有一个RP 感应系数P ,P乘以此处RP场强度即时此人此时的RP值的数学期望,而RP的具体值实在其周围以正态形式分布,而且是符合测不准原理的。 具体定义: RP单位 德,符号De. Rp感应系数单位 品,符号Pn. Rp场强度单位 运,符号 Yn. Rp常量单位 米每品,符号 m/Pn; 另:RP场的梯度是RP流动速度的场。于是其速度随距离的增加呈二次方反比递减。 然而, 一个人的RP势能很低,并不代表RP能量就会向他流动,因为这些能量还受到周边人、物的RP引力制约。只能说,RP低的人在同等条件下更容易接受RP能量,从而升高RP势能;RP势能高容易失去RP(多数以无用的形式流向大自然,因为这是必然事件,那么),为了维持较高的RP势,我们就要不断的补充。但是RP势能高,并不代表就会有你说期待的好事发生,有可能这些RP以其他你所不期待的形式释放了,我们称作为RP亏损,这就取决于你的RP利用率了。所以,我们在汲取RP的同时,还要锻炼我们的RP利用率。 这里要说一个自然损失,因为这是必然事件,所以P=1,那么RP的损失量就直接和你的w值有关了,也就是,如果你正确认识了这种必然性,你的RP只会损失1,如果你非常不想让它损失那么你将损失更多的RP能量,所以,调整心态是很重要的啊~! RP的持续性浅析 如何评价日常行为与RP的关系 RP的变化与操控 RP的几大定律 研究认为,RP学也是科学,即也满足科学的基本原理: 一、对称性原理 二、守恒原理 三、平衡原理 四、叠加原理 详见 LBY(Lord Beyond Yahweh的 《科学的一些基本原理》一文) RP第一定律 RP是守恒的,它既不会凭空产生,也不会凭空消失 宇宙创生之初,与各大基本粒子同时由爆炸奇点生成的一大暗物质种类就是RP。经过笔者的多年探究和无数实验,配合与史蒂芬霍金的理论研究合作,已经基本从理论高度证明了RP第一定律,也称为"RP守恒定律"。 这一定理的理解往往不像物理学中的热力学第一定律那样好理解,因为在实际生产生活实践中,往往会发现某人的RP大量减少,但是并没有发现某人的RP有明显的提升,所以也导致在很长一段时间内大量研究人员质疑RP守恒定律的正确性。进一步研究发现,RP的存在和守恒是确定的只是由于绝大多数RP往往存在于生物体之外而以自由RP”的形式游离于宇宙空间,所以,以上那种情况仅仅表明某人的RP由于自身原因散佚于宇宙空间,却没有人从空间中汲取RP,从而导致有效RP减少,也就是发挥作用的RP减少了,但并没有影响RP本身的守恒。 RP第二定律 RP不可以从低RP物体传向高RP物体而不引起其他变化。 但由于RP的不确定性,RP可以从RP的数学期望低的物体传向高RP数学期望物体,这与第二定律不矛盾。 RP第三定律 对大量的事实的分析表明,绝对没RP不可能达到。 推论 大量的实践表明,RP将会大量消耗在一些琐事或发生概率较低的事物上,其消耗程度与事件的发生概率成反比,与事件产生后果的大小成反比。 RP的变化因素 总的来说,RP的变化因素不可控因素比可控因素占的因素还多,发生在身边的任何事都可能改变你的RP,正是因为这样,RP才经常变化于无形中,但是这不是我们放弃研究RP的理由,要在复杂的情况中提炼出简单的规律,化繁为简。笔者经过多年实践观察总结,列出了如下表格描述各种因素与RP的变化关系: 事件 对RP影响(单位:fs) 事件 对RP影响(单位:fs) 考试爆0 +6 星际,羽毛球等被虐 +5 扶老奶奶过街 +3 星际,羽毛球,war3等虐人 -10 八卦zmy -20 jf不幸滴看见某人 -100 (注:单位“fs“的定义为:vijosAC一道题所需要的RP的量) 由上述表格可以看出,积累RP是不容易的,但是积累的RP却很容易在不经意之间丢失,(所谓大自然厌恶高RP”,也就是说,RP越高的人,丢失RP也就会显得越容易)。这就是为什么很多人抱怨自己的RP从来就没好过,那是因为他们好不容易有点RP了,却由于自己不小心又做的损RP的事情而把宝贵的RP丢失了。(RP易挥发) 人为调节RP的技巧与方法 说实话,对这一节的内容笔者没有十分的把握,因为笔者本人对这部分内容一直都很困惑,我希望能通过一些人为手段调节可怜的RP,但是理论跟实践的差距往往相当大,我理论分析总结的规律在实践中有时并不能行通,就像我有时候可以地遵守交通规则,不闯红灯,听妈妈的话等等等等,原本以为这样可以积累RP,无奈考试还是要爆0,说白了就是RP对人似乎有天生的抵触情节,最经典的例子是与笔者同校的一个叫LKQ(化名)的同学在NOI之前不幸将自己的手机搞丢,本以为自己RP会增长到一定的程度,以帮助自己在NOI上获得较好的成绩,结果事与愿违,NOI还是不幸考挂,所以我们分析一个现实生活中的RP问题,一定不能拘泥于某一些事情对于RP的影响,而应该纵览全局,客观考虑各种因素的影响,才能最后得出准确的结论,事实证明那位同学在NOI上被室友塞了满满一抽屉的硬币,硬币虽小,但对RP的影响却是巨大的,正如刚才论述的,RP失去容易获得难,虽然手机的价值远大于硬币,但是对于失去手机RP有所增长的这位仁兄来说,获得硬币所损失的RP更是一个恐怖的数字。所以要客观和全面地分析问题,才能获得准确和有效的结论。 但是我们不能因此就放弃对RP的调节,我们需要持之以恒的调节RP。因为根据SW的经验来看,追MM、谈恋爱等事情需要耗费巨大的RP。例如:SW和其女同学一起吃完KFC出去的时候,其女同学说也许我们出去就会被汽车一起撞死,为了避免这种悲剧发生,SW不得不支付大量RP……所以各位需要不断的累积RP,来应付各种突发状况…… RP之变诈几何哉?止增笑耳。 {小附一言,速增RP之方法,简单,易行,附带练习SC:找个变速齿轮,16*打三个R,速度快,见效好,某附言者同学ZLC以此法自虐一下午,出关后期末考不负众望,年段第一……} RP的奇律 任何理论都有其局限性,当然经典rp理论也是一样,某些时候rp会从某个人身上大量的涌现(俗称:rp爆发),而此人之前的rp值表现平常甚至很低或者显示为负。这种现象称为rp的奇律。rp爆发相当罕见,因此研究甚少,成果有待完善。 最近研究表明:RP爆发一般是一种其概率与自己希望爆发的程度2次方成反比的情况。 上述事实表明,经典rp理论有其局限性.这里我们就要以量子rp理论进行改进.可以证明,rp具有量子特征,其概率幅函数满足一维无限深势阱的薛定谔微分方程;rp可以自发跃迁,也可以激发跃迁.此时会放出某种特殊的波,在宏观上表现就是一些离奇事件的发生;rp满足海森堡不确定性原理,delta(p)*delta(E)>=h/(4*pi);rp仅可以用统计观点来阐释,即只能大体说明在一段时间内某部分的人的rp有怎样的统计规律,任何企图精确说明某时刻在某人的rp,进而预测其做事的成功尝试都是不可能的,也是没有意义的. RP故事 最近研究表明,RP对包括物理竞赛在内的各门竞赛,也有极大影响。 Lord Beyond Yahweh在参加今年物理竞赛时,计算所谓16小时轨道的实际周期,算得7.8..小时,感觉不对,乘以2=15.77后写了上去,竟对了,这与他最近一直以宇宙公民的要求(节约能源,减少宇宙的熵增,推迟宇宙灭亡)要求自己有很大关系。 某菜ZZQ在英语考试听力完全没有听清的情况下,竟以全部蒙对的情况收场。后经调查了解到,这是其通过考前扶老奶奶过马路的优秀行为,积攒了RP所致。 某盲WDGF{1}时不幸光荣地挂了,经有关部门详细调查,发现其在打大菠萝时逆天行道,用ATMA无耻的修改了存档的行为,使RP无限接近0所致。 RP学派 由于研究RP不仅是研究一种物质,更是在研究一门哲学,所以RP的研究方向也自然而然的被划分为2个方向:一种是认为RP的客观物质场左右人的主观意识和行为为主的唯物RP学派,着重研究RP的客观变化;另一种是认为人的主观意识左右RP物质场为主的唯心RP学派,着重研究人对RP客观的影响。虽然有分类,但是二大学派都把研究RP对人的客观行为(如GF{1}NOIPSC,CS,HL)的影响等作为重要的研究方向。-_______OiBLtx 1:此处GF词类活用,做动词,意为找GF。 来自:http://www.nocow.cn/index.php/RP%E5%AF%BC%E8%AE%BA

<p> 技巧题 </p> <p> <br /> 输入:一堆乱码 </p>

输出"Hello World!"(带引号!)<br />

(和谐)

"Hello World!"(带引号!)

0

。。。

 

2018-03-21 21:04:32

1

64

N

8

10

0

1399

【入门题】4.16_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_16.jpg>

读入多个数据

输出多行,每行对应3个数据(输出作实数据类型处理,各个数据小数点后保留两位,数据间用空格隔开。)

0 1 2 3 -3

0.00 0.00 1.00 1.00 0.00 2.00 1.41 0.69 3.00 1.73 1.10

0

了解不同函数特征,注意特殊数据零。

 

2017-04-15 21:09:09

1

64

N

0

1

0

1400

【入门题】4.17_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_17.jpg>

输入一行字符串,并以字符“;”结束。

对不同的输入数据对应以下三种处理结果: (1)右括号先出现输出:error 1:right brackets is first appear! 2)左括号比右括号多:error 2:left brackets are more then right brackets! 3)左括号与右括号匹配成功:OK!

((a+b)*c/d)/2;

OK!

0

 

 

2017-04-15 21:09:09

1

64

N

3

4

0

1401

【入门题】4.18_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_18.jpg>

输入字符串,可能存在多行。

输出字符串中对应的字母个数 输出字符串中对应的数字个数 输出字符串中对应的其它字符个数

adfa1@#$789-=-a2?

letter:5 number:5 others:7

0

着重了解一下回车字符串的具体构成,并做出解释。

 

2017-04-15 21:09:09

1

64

N

1

3

0

1402

【入门题】4.19_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_19.jpg>

数据有多行,每行3个数据,分别为:abc

输出数据以实数类型显示,小数点后保留两位。 分三种情形: (1)有两个实根的情况 形如: it has two real roots: x1=-0.30 x2=-6.70 2)仅有一个实根的情况 形如: it has one real root: x=-1.00 3delta<0,存在两个共轭复根(数据写成a+bi形式,ab为实数,“i”为标示) 形如: it has two complex roots: x1=-1.00+1.41i x2=-1.00-1.41i

1 7 2 2 4 2 1 2 3 0 0 0

it has two real roots: x1=-0.30 x2=-6.70 it has one real root: x=-1.00 it has two complex roots: x1=-1.00+1.41i x2=-1.00-1.41i

0

简单地了解一下共轭复根所特有的表达形式,并说出复根有何存在的意义。 ……………………共轭复根…………………… 两个实部相等,虚部互为相反数的复数互为共轭复数(conjugate complex number)。(当虚部不等于0时也叫共轭虚数)复数z的共轭复数记作。   根据定义,若zabi(ab∈R),则 abia,b∈R)。共轭复数所对应的点关于实轴对称。   1.代数特征:   (1|z||z′|;   (2zz′2a(实数),zz′2bi;   (3z• z′|z|^2a^2b^2(实数);   (4z″z.   2.运算特征:   (1(z1+z2)′=z1′+z2′   (2 (z1-z2)′=z1′-z2′   (3 (z1·z2)′=z1′·z2′   (4 (z1/z2)′=z1′/z2′ (z2≠0)   3 模的运算性质:   ① | z1·z2| = |z1|·|z2|     ③┃| z1|| z2|┃≤| z1+z2|≤| z1|+| z2|   | z1z2| = | z1z2|,是复平面的两点间距离公式,由此几何意义可以推出复平面上的直线、圆、双曲线、椭圆的方程以及抛物线   ps:z′表示复数z的共轭复数(实际形式为z上一横)z″表示复数z的共轭复数的共轭复数(z上两横)

 

2017-04-15 21:09:09

1

64

N

1

1

0

1403

【入门题】4.20_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_20.jpg>

读入数据可能存在多行,每行仅有两个数据,ab

输出对应的最大公约数 输出对应的最小公倍数

4 9 3 7 16 48

4 9the greatest common divisor is : 1 9 4the lowest common multiple is : 36 3 7the greatest common divisor is : 1 7 3the lowest common multiple is : 21 16 48the greatest common divisor is : 16 48 16the lowest common multiple is : 48

0

1)重点了解一下阿基米德算法求两个数的最大公约数,并要求给出数学方面的证明。(推荐!) (2)了解求两个数的最小公倍数算法。 (3)了解求两个数的最大公约数一般方法。

 

2017-04-15 21:09:09

1

64

N

1

1

0

1404

【入门题】4.21_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_21.jpg>

输入数据可能存在多个。

分多行输出。 每行仅输出,对应x的值及其对应的cosx)函数值。(每对数据中间用空格隔开,小数点后均保留六位) 具体输出格式请参看样例。

1.5 2.3 4 0

x=1.500000 cos(1.500000)=0.070737 x=2.300000 cos(2.300000)=-0.666276 x=4.000000 cos(4.000000)=-0.653644 x=0.000000 cos(0.000000)=1.000000

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1405

【入门题】4.22_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_22.jpg>

输入数据可能存在多个。

分多行输出。 每行仅输出,对应x的值及其对应的s值。(每对数据中间使用空格隔开,小数点后均保留五位) 具体输出格式请参看样例。

0.874 -0.992 -0.232 0.1234

x=0.87400 s=1.39648 x=-0.99200 s=-0.62917 x=-0.23200 s=-0.20705 x=0.12340 s=0.13134

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1406

【入门题】4.23_P88

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_23.jpg>

输入数据可能存在多个。

对其中每个输入数据,其输出处理分两行进行: (1)第一行,输出x的值,小数点后保留四位。 (2)第二行,输出对应x值的开3次方根值,小数点后保留四位。 体输出格式请参看样例。

27 512

x=27.0000 The 3th root of 27.0000 is: 3.0000 x=512.0000 The 3th root of 512.0000 is: 8.0000

0

对问题思考注意全面,注意特殊值的取值。

 

2017-04-15 21:09:09

1

64

N

1

1

0

1407

【入门题】4.24_P89

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_24.jpg>

输入数据可能存在多组x取值。 每组数据处理及其说明: (1):每组x数据共 5个。读入时占用一行,并用空格隔开,5个数据分别表示x[1]x[2]x[3]x[4]x[5]。 (2):每组y数据共10个。且各组y[1]y[2]y[3]……y[10]均相同,分别为:3.03.13.2……3.9。无输入数据给出)

分多行输出,每行仅一个数据。 (各输出数据类型均为实型,输出时小数点后保留8位输出。) 具体输出格式请参看样例。

1.25 2.31 3.47 4.52 5.29

f[1,1]=0.41454923 f[1,2]=0.42121243 f[1,3]=0.42772418 f[1,4]=0.43409122 f[1,5]=0.44031983 f[1,6]=0.44641591 f[1,7]=0.45238497 f[1,8]=0.45823221 f[1,9]=0.46396250 f[1,10]=0.46958042 s[1]=4.42847291 f[2,1]=0.16572578 f[2,2]=0.16757772 f[2,3]=0.16939574 f[2,4]=0.17118106 f[2,5]=0.17293484 f[2,6]=0.17465817 f[2,7]=0.17635209 f[2,8]=0.17801759 f[2,9]=0.17965560 f[2,10]=0.18126702 s[2]=1.73676559 f[3,1]=0.05810098 f[3,2]=0.05857824 f[3,3]=0.05904830 f[3,4]=0.05951135 f[3,5]=0.05996762 f[3,6]=0.06041730 f[3,7]=0.06086057 f[3,8]=0.06129761 f[3,9]=0.06172861 f[3,10]=0.06215371 s[3]=0.60166429 f[4,1]=0.02196933 f[4,2]=0.02211317 f[4,3]=0.02225514 f[4,4]=0.02239529 f[4,5]=0.02253365 f[4,6]=0.02267028 f[4,7]=0.02280521 f[4,8]=0.02293849 f[4,9]=0.02307016 f[4,10]=0.02320026 s[4]=0.22595098 f[5,1]=0.01066357 f[5,2]=0.01072403 f[5,3]=0.01078377 f[5,4]=0.01084280 f[5,5]=0.01090116 f[5,6]=0.01095884 f[5,7]=0.01101588 f[5,8]=0.01107227 f[5,9]=0.01112805 f[5,10]=0.01118321 s[5]=0.10927358

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1408

【入门题】4.25_P89

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_25.jpg>

输入数据可能存在多组x取值。 每组数据处理及其说明: (1):每组x数据共 5个。读入时占用一行,并用空格隔开,5个数据分别表示x[1]x[2]x[3]x[4]x[5]。 (2):每组y数据共10个。且各组y[1]y[2]y[3]……y[10]均相同,分别为:2.12.22.3……3.0。无输入数据给出)

分多行输出,每行仅一个数据。 (各输出数据类型均为实型,输出时小数点后保留4位输出。) 具体输出格式请参看样例。

1 3 5 7 9

f[1,1]=0.0134 f[1,2]=-0.0182 f[1,3]=-0.0478 f[1,4]=-0.0752 f[1,5]=-0.1002 f[1,6]=-0.1229 f[1,7]=-0.1432 f[1,8]=-0.1610 f[1,9]=-0.1764 f[1,10]=-0.1892 f[2,1]=-0.1268 f[2,2]=-0.1162 f[2,3]=-0.1054 f[2,4]=-0.0942 f[2,5]=-0.0830 f[2,6]=-0.0717 f[2,7]=-0.0605 f[2,8]=-0.0494 f[2,9]=-0.0385 f[2,10]=-0.0279 f[3,1]=0.0634 f[3,2]=0.0661 f[3,3]=0.0680 f[3,4]=0.0691 f[3,5]=0.0695 f[3,6]=0.0691 f[3,7]=0.0681 f[3,8]=0.0666 f[3,9]=0.0644 f[3,10]=0.0618 f[4,1]=0.0203 f[4,2]=0.0136 f[4,3]=0.0073 f[4,4]=0.0014 f[4,5]=-0.0041 f[4,6]=-0.0091 f[4,7]=-0.0137 f[4,8]=-0.0178 f[4,9]=-0.0215 f[4,10]=-0.0247 f[5,1]=-0.0500 f[5,2]=-0.0471 f[5,3]=-0.0440 f[5,4]=-0.0407 f[5,5]=-0.0373 f[5,6]=-0.0337 f[5,7]=-0.0301 f[5,8]=-0.0265 f[5,9]=-0.0228 f[5,10]=-0.0192 s=-0.3512

0

P1407非常类似。

 

2017-04-15 21:09:09

1

64

N

1

1

0

1409

【入门题】4.26_P89

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_26.jpg>

无输入数据

具体输出格式请自行观察!

 

a a b a b c a b c d a b c d e a b c d e f a b c d e f g a b c d e f g h a b c d e f g h i a b c d e f g h i j a b c d e f g h i j k …… …… …… …… …… …… …… …… …… …… … …… …… …… …… …… …… …… …… …… a b c …… …… ……

0

观察题!

 

2017-04-15 21:09:09

1

64

N

1

1

0

1410

【入门题】4.27_P89

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_27.jpg>

无输入数据

具体输出格式请自行观察!

 

1 1 2 1 1 2 3 2 1 1 2 3 4 3 2 1 …… …… …… …… …… 1 2 3 ……

0

观察题!

 

2017-04-15 21:09:09

1

64

N

1

1

0

1411

【入门题】4.28_P89

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_28.jpg>

输入数据可能存在多个n(其中n为正整数类型,n不大于100000

对于每个数据n处理: (1)输出1——n之间所有的素数。存在多个素数时,每行输出十个。 (2)在最底行另起一行,输出素数总个数。 (整数输出时,场宽定义为8

10 50

1..10 prime number: 2 3 5 7 total:4 1..50 prime number: 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 total:15

0

掌握求素数的一般算法。

 

2017-04-15 21:09:09

1

64

N

0

1

0

1412

【入门题】4.29_P89

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_29.jpg>

输入数据可能有多个。 对于每一个数据n而言,均有(4<=n<=50000)。

对于其中每一个数据n: 所有大于等于4且小于等于n之间的偶数,表示成两个素数之和。 具体输出格式请参看样例。

20 35

n:20 4=2+2 6=3+3 8=3+5 10=3+7 12=5+7 14=3+11 16=3+13 18=5+13 20=3+17 n:35 4=2+2 6=3+3 8=3+5 10=3+7 12=5+7 14=3+11 16=3+13 18=5+13 20=3+17 22=3+19 24=5+19 26=3+23 28=5+23 30=7+23 32=3+29 34=3+31

0

清晰的结构条理思维有助于程序过程的设计!

 

2017-04-15 21:09:09

1

64

N

1

1

0

1413

【入门题】4.30_P90

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_30.jpg>

输入数据可能存在多个。 对于每一个数据n而言,均有(2<=n<=10000)。

对于其中每一个数据n: 处理从2n之间所有的数,将其表达成多个素数因子积的形式。 (单独一行输出显示:一个数的素数因子积的表达形式。) 具体输出格式请参看样例。

20 45

n:20 2=2 3=3 4=2*2 5=5 6=2*3 7=7 8=2*2*2 9=3*3 10=2*5 11=11 12=2*2*3 13=13 14=2*7 15=3*5 16=2*2*2*2 17=17 18=2*3*3 19=19 20=2*2*5 n:45 2=2 3=3 4=2*2 5=5 6=2*3 7=7 8=2*2*2 9=3*3 10=2*5 11=11 12=2*2*3 13=13 14=2*7 15=3*5 16=2*2*2*2 17=17 18=2*3*3 19=19 20=2*2*5 21=3*7 22=2*11 23=23 24=2*2*2*3 25=5*5 26=2*13 27=3*3*3 28=2*2*7 29=29 30=2*3*5 31=31 32=2*2*2*2*2 33=3*11 34=2*17 35=5*7 36=2*2*3*3 37=37 38=2*19 39=3*13 40=2*2*2*5 41=41 42=2*3*7 43=43 44=2*2*11 45=3*3*5

0

良好的程序思想有助于问题的求解。(类似筛法思想参照)

 

2017-04-15 21:09:09

1

64

N

1

1

0

1414

【入门题】4.31_P90

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_31.jpg>

输入数据可能存在多个。 对于每一个数据n而言,均有(2<=n<=10000)。

对于其中每一个数据n: 输出从2n之间所有的完数。 (数据为整数类型,输出时其场宽为6) 具体输出格式请参看样例。

20 100

n:20 6 n:100 6 28

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1415

【入门题】4.32_P90

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_32.jpg>

输入数据可能存在多个。 对于每一个数据n而言,均有(2<=n<=10000)。

对于其中每一个数据n: 输出从2n之间所有的亲密数对(ab),且a小于b。 每行仅输出一对亲密数对(对于一个数据n,可能有多行输出)。 具体输出格式请参看样例。

500 1000

n:500 (220,284) n:1000 (220,284)

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1416

【入门题】4.33_P90

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO4/4_33.jpg>

无输入数据。

列出所有可行方案。 每行列出一种方案,共4个数据,中间用空格隔开。 (其中4个数据依次表示10元、5元、2元、1元货币面值所用数量。) 具体输出格式请参看样例。

无输入数据。

1 5 31 3 1 6 27 6 1 7 23 9 1 8 19 12 1 9 15 15 1 10 11 18 1 11 7 21 1 12 3 24 2 2 34 2 2 3 30 5 2 4 26 8 2 5 22 11 2 6 18 14 2 7 14 17 2 8 10 20 2 9 6 23 2 10 2 26 … … … … total:34

0

 

 

2017-04-15 21:09:09

1

64

N

0

1

0

1417

【入门题】5.1_P122

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_1.jpg>

输入一个实数类型数据x0<=x<=0.5)。

输出一个实数类型值,且保留小数点后两位有效数据。

0.12345 0.3323

0.87 0.63

0

 

 

2017-04-15 21:09:09

1

64

N

0

2

0

1418

【入门题】5.2_P122

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_2.jpg>

一行输入两个整数:nk

一行输出一个整数m。(其中m为整数n从右向左数过去的第k位数值。)

15151515 5

5

0

提示:其中n也有可能为负值哦!

 

2017-04-15 21:09:09

1

64

N

1

1

0

1419

【入门题】5.3_P122

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_3.jpg>

输入一行,两个整数nd

输出一行,如果数值d出现在n中某位上,则输出为true;否则输出false

123456789 1 987654321 123456

true false

0

 

 

2017-04-15 21:09:09

1

64

N

0

2

0

1420

【入门题】5.4_P122

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_4.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1421

【入门题】5.5_P122

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_5.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1422

【入门题】5.6_P122

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_6.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1423

【入门题】5.7_P123

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_7.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1424

【入门题】5.8_P123

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_8.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1425

【入门题】5.9_P123

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_9.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1426

【入门题】5.10_P123

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_10.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1427

【入门题】5.11_P123

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_11.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1428

【入门题】5.12_P123

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_12.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

2

0

1429

【入门题】5.13_P123

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_13.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1430

【入门题】5.14_P124

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_14.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

0

1

0

1431

【入门题】5.15_P124

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_15.jpg>

 

 

 

输出小数点后保留4位。

0

 

 

2017-04-15 21:09:09

10

64

N

1

1

0

1432

【入门题】5.16_P124

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_16.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1433

【入门题】5.17_P124

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_17.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1434

【入门题】5.18_P124

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO5/5_18.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1435

【入门题】6.1_P135

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO6/6_1.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1436

【入门题】6.2_P135

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO6/6_2.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1437

【入门题】6.3_P135

 

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1438

【入门题】7.1_P170

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_1.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1439

【入门题】7.2_P170

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_2.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1440

【入门题】7.3_P170

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_3.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1441

【入门题】7.4_P170

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_4.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1442

【入门题】7.5_P170

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_5.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1443

【入门题】7.6_P170

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_6.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1444

【入门题】7.7_P170

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_7.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

2

0

1445

【入门题】7.8_P171

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_8.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1446

【入门题】7.9_P171

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_9.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1447

【入门题】7.10_P171

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_10.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1448

【入门题】7.11_P171

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_11.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1449

【入门题】7.12_P171

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_12.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1450

【入门题】7.13_P171

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_13.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

4

0

1451

【入门题】7.14_P171

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_14.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

4

4

0

1452

【入门题】7.15_P172

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_15.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1453

【入门题】7.16_P172

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_16.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1454

【入门题】7.17_P172

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_17.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1455

【入门题】7.18_P172

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_18.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1456

【入门题】7.19_P172

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_19.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

4

4

0

1457

【入门题】7.20_P172

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_20.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1458

【入门题】7.21_P173

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/tsinghua/NO7/7_21.jpg>

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1459

【模拟题】开灯

开灯(light.pas/c/cpp) 【题目描述】 在一条无限长的路上,有一排无限长的路灯,编号为1234……。 每一盏灯只有两种可能的状态,开或者关。如果按一下某一盏灯的开关,那么这盏灯的状态将发生改变。如果原来是开,将变成关。如果原来是关,将变成开。 在刚开始的时候,所有的灯都是关的。 小明每次可以进行如下的操作: 指定两个数,ata为实数,t为正整数)。将编号为[a][2*a][3*a]……[t*a]的灯的开关各按一次。其中[k]表示实数k的整数部分。 在小明进行了n次操作后,小明突然发现,这个时候只有一盏灯是开的,小明很想知道这盏灯的编号,可是这盏灯离小明太远了,小明看不清编号是多少。 幸好,小明还记得之前的n次操作。于是小明找到了你,你能帮他计算出这盏开着的灯的编号吗?

第一行一个正整数n,表示n次操作。 接下来有n行,每行两个数,aiti。其中ai是实数,小数点后一定有6位,ti是正整数。

仅一个正整数,那盏开着的灯的编号。

3 1.618034 13 2.618034 7 1.000000 21

20

0

【数据规模】 记T=t1+t2+t3+……+tn。 对于30%的数据,满足T<=1000 对于80%的数据,满足T<=200000 对于100%的数据,满足T<=2000000 对于100%的数据,满足n<=50001<=ai<10001<=ti<=T 数据保证,在经过n次操作后,有且只有一盏灯是开的,不必判错。

NOIP2009模拟试卷《NOI专刊》

2017-04-15 21:09:09

1

64

N

1

2

0

1460

【模拟题】打砖块

打砖块(game.pas/c/cpp) 【题目描述】 小红很喜欢玩一个叫打砖块的游戏,这个游戏的规则如下: 在刚开始的时候,有n*m列的砖块,小红有k发子弹。小红每次可以用一发子弹,打碎某一列当前处于这一列最下面的那块砖,并且得到相应的得分。 如图所示: 某些砖块在打碎以后,还可能将得到一发子弹的奖励。最后当所有的砖块都打碎了,或者小红没有子弹了,游戏结束。 小红在游戏开始之前,就已经知道每一块砖在打碎以后的得分,并且知道能不能得到一发奖励的子弹。小红想知道在这次游戏中她可能的最大得分,可是这个问题对于她来说太难了,你能帮帮她吗?

第一行有3个正整数,nmk。表示开始的时候,有n*m列的砖块,小红有k发子弹。 接下来有n行,每行的格式如下: f1 c1 f2 c2 f3 c3 …… fm cm 其中fi为正整数,表示这一行的第i列的砖,在打碎以后的得分。ci为一个字符,只有两种可能,Y或者NY表示有一发奖励的子弹,N表示没有。 所有的数与字符之间用一个空格隔开,行末没有多余的空格。

仅一个正整数,表示最大的得分。

3 4 2 9 N 5 N 1 N 8 N 5 N 5 Y 5 N 5 N 6 N 2 N 4 N 3 N

13

0

【数据规模】 对于20%的数据,满足1<=n,m<=51<=k<=10,所有的字符c都为N 对于50%的数据,满足1<=n,m<=2001<=k<=200,所有的字符c都为N 对于100%的数据,满足1<=n,m<=2001<=k<=200,字符c可能为Y 对于100%的数据,所有的f值满足1<=f<=10000

NOIP2009模拟题《NOI专刊》

2017-04-15 21:09:09

1

64

N

1

1

0

1461

【模拟题】长方形

长方形(rectangle.pas/c/cpp) 【题目描述】 小明今天突发奇想,想从一张用过的纸中剪出一个长方形。 为了简化问题,小明做如下的规定: (1)这张纸的长度、宽度分别为nm。小明将这张纸看成是由n*m个格子组成,在剪的时候,只能沿着格子的边缘剪。 (2)这张纸有些地方小明以前在上面画过,剪出来的长方形不能含有以前画过的地方。 (3)剪出来的长方形的大小没有限制。 小明看着这张纸,想到了好多好多种剪的方法,可是到底有多少种呢?小明数不过来了,你能帮帮他吗?

第一行两个正整数,nm,表示这张纸的长度和宽度。 接下来有n行,每行m个字符,每个字符为‘*’或者‘.’。 字符‘*’表示以前在这个格子上画过,字符‘.’表示以前在这个格子上没有画过。

仅一个整数,表示方案数。

6 4 .... .*** .*.. .*** ...* .***

38

0

【数据规模】 对于10%的数据,满足1<=n<=101<=m<=10 对于30%的数据,满足1<=n<=501<=m<=50 对于60%的数据,满足1<=n<=2001<=m<=200 对于100%的数据,满足1<=n<=10001<=m<=1000 最后一个点所有的字符都为‘.’

NOIP2009模拟题《NOI专刊》

2017-04-15 21:09:09

1

64

N

0

0

0

1462

【模拟题】收费站

收费站(cost.pas/c/cpp) 【题目描述】 在某个遥远的国家里,有n个城市。编号为123……n。 这个国家的政府修建了m条双向的公路。每条公路连接着两个城市。沿着某条公路,开车从一个城市到另一个城市,需要花费一定的汽油。 开车每经过一个城市,都会被收取一定的费用(包括起点和终点城市)。所有的收费站都在城市中,在城市间的公路上没有任何的收费站。 小红现在要开车从城市u到城市v(1<=uv<=n)。她的车最多可以装下s升的汽油。在出发的时候,车的油箱是满的,并且她在路上不想加油。 在路上,每经过一个城市,她要交一定的费用。如果她某次交的费用比较多,她的心情就会变得很糟。所以她想知道,在她能到达目的地的前提下,她交的费用中最多的一次最少是多少。这个问题对于她来说太难了,于是她找到了聪明的你,你能帮帮她吗?

第一行5个正整数,nmuvs。分别表示有n个城市,m条公路,从城市u到城市v,车的油箱的容量为s升。 接下来有n行,每行1个正整数,fi。表示经过城市i,需要交费fi元。 再接下来有m行,每行3个正整数,aibici(1<=aibi<=n)。表示城市ai和城市bi之间有一条公路,如果从城市ai到城市bi,或者从城市bi到城市ai,需要用ci升汽油。

仅一个整数,表示小红交费最多的一次的最小值。 如果她无法到达城市v,输出-1

【输出样例1 4 4 2 3 8 8 5 6 10 2 1 2 2 4 1 1 3 4 3 4 3 【输入样例2 4 4 2 3 3 8 5 6 10 2 1 2 2 4 1 1 3 4 3 4 3

【输出样例1 8 【输出样例2 -1

0

【数据规模】 对于60%的数据,满足n<=200m<=10000s<=200 对于100%的数据,满足n<=10000m<=50000s<=1000000000 对于100%的数据,满足ci<=1000000000fi<=1000000000,可能有两条边连接着相同的城市。

NOIP2009模拟题《NOI专刊》

2017-04-15 21:09:09

1

64

N

0

1

0

1463

【模拟题】天天去旅行

天天去旅行 (trip.pas/c/cpp) 【题目描述】 暑假到了,天天和妈妈一起背包去西藏玩(话说西藏最近不清静啊~),天天想带好多东西的,可是,包包的容量是有限的,她,必须得扔掉些东西。她收拾包已经头昏脑胀的了,所以求助于你,希望你能帮自己算算能最多带多少东西。 每个东西对于天天来说,有一个重要值,天天当然希望越重要的东西都带着咯,所以,你所需要做的,就是算出她能带东西的总最大重要值。

trip.in 1行为天天想带的东西的数量n(n≤100)和包包的最大容量VV≤1000) 第2~n+1行,每行2个数m[i]p[i],分别表示这个物品的大小、重要度。

trip.out 一个数,表示天天所能带的东西的最大重要度。

3 71 72 100 69 1 1 1

2

0

【数据规模】 30%数据 V≤10 100%数据 V≤1000

OIBH普及版模拟题7

2017-04-15 21:09:09

1

64

N

2

2

0

1464

【模拟题】天天写作业

homework.pas/c/cpp) 【题目描述】 暑假作业好多天天写的头都大了,数学题里有一题,题目很简单,可是把天天纠结了很久了。。。计算从[A,B](闭区间包括AB, A <= B, 0<=B <= 1000000000, B - A <= 100000)之间,一共有多少素数?(不要交表!程序不能大于3KB。。。)

homework.in 一行,两个整数,用空格分开,分别是AB

homework.out 一行,代表[A,B]之间有多少素数。

3 10

3

0

 

OIBH普及版模拟题7

2017-04-15 21:09:09

1

64

N

5

29

0

1465

【模拟题】天天做实验

experiment.pas/c/cpp) 【题目描述】 物理实验室里有一个天平的模型。模型每个臂长15个单位长度,在C(C <= 20)个整数长度点上,有钩子可以挂砝码。我有G个砝码(G <= 20),每个砝码重量均是不同的整数,范围1..25。我遇到的难题是:有多少种挂砝码的方法,使得天平平衡?(不可以不挂砝码。。。但不一定要挂所有的砝码)   天平平衡的条件是:左边的力矩 = 右边的力矩,力矩 = L1 * W1 + L2 * W2 + ..,其中L为到平衡点的距离,W为砝码的重量

experiment.in 第一行CG。 第2C个整数,代表可以挂砝码的刻度点。正数代表右臂,负数代表左臂。 第3G个整数,代表砝码的重量。

experiment.out 一行,代表方案总数。

2 4 -2 3 3 4 5 8

2

0

 

OIBH普及版模拟题7

2017-04-15 21:09:09

1

64

N

1

2

0

1466

【模拟题】天天玩游戏

game.pas/c/cpp) 【问题描述】 天天和朋友们玩一种叫做钩形覆盖的游戏。 游戏规则是这样的。。。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/p1466.GIF> 这个图形即是钩形,钩形经过旋转、翻转以后仍然为钩形。 现在,请问,用这些钩形覆盖N * M(N, M <= 30)的矩形,是否能够不重复、不遗漏、不出边界地覆盖?

game.in 每个测试点包含多组测试数据! 测试数据第一行Tn,代表测试数据的组数。Tn <= 10。 以后Tn行,每行两个数:NM

game.out 每组测试数据输出一行,假如能够完全覆盖,则输出"Yes",否则输出"No"

2 3 4 3 3

Yes No

0

 

OIBH普及版模拟题7

2017-04-15 21:09:09

1

64

N

2

2

0

1467

【模拟题】集卡片(card

boboo小时候很喜欢收集卡片,他经常要去商店购买新到的卡片。 商店出售的卡片有N张,是连续的,并且都连在一起成为一个长串,商店阿姨告诉boboo只能购买连续的一段,这一串卡片共有M种,每种卡片都有一个价格,boboo拿的钱数为V,他想花最少的钱来集齐所有种类的卡片,你能帮帮他吗?

1行 三个正整数 NMV 2行共M个正整数,第i个数Ti表示第i种卡片的价格 第3 N个正整数,表示卡片序列。

1 1个整数ans,表示boboo剩余的钱数,若不能集齐,输出’NO ans’,不含引号。

5 2 20 10 5 1 1 2 2 1

5

0

【样例解释】 购买2-3 或者 4-5 都可,花费15,剩余钱数20-15=5. 【数据范围】 对于100%的数据 N<=1000000 M<=2000 Ti<=2000 , V<=10^9 对于30% 的数据 N<=2000 来源 By Boboo

NOIP2009•Dream Team 模拟赛

2017-04-15 21:09:09

2

256

N

1

1

0

1468

【模拟题】天堂(heaven

每一个要上天堂的人都要经历一番考验,当然包括小X,小X开始了他进入天堂的奇异之旅。地狱有18层,天堂竟然和地狱一样,也有很多很多层,天堂共有N层。从下到上依次是第123N层,天堂的每一层都是一个延伸无限远的地板,在地板上人可以任意走动,层与层之间是平行关系,每一层的地板都是由人不能穿过的物质构成,幸好每一层地板上有且仅有1个人可以通过的洞口。 我们可以把小X和洞口,还有下面提到的气球店都看成点,坐标是二维的。小X开始在第1层的(00. X的重量为M,第i层与第i+1层之间的特殊气体能浮起的重量为Wi ,每一层的地面上散落了若干个气球店,多个气球店可以在同一点,每个气球可以浮起的重量是1,去一个气球店一次只能领取一个气球,不能连续在一个气球店领取气球,当然你可以在两个气球店之间来回跑,每个气球店供应的气球都是无限多的。第i层的气球只能在第i层进入第i+1层时使用,当小X在第i层,只有站到了第i+1层洞口的位置(在其它位置不会浮起),并且自身的重量小于等于气球和特殊气体浮起重量的总和,才可以进入第i+1层。小X想知道他要到达第N层走过的长度最少是多少?题目保证有解。

1行: 三个正整数NMQQ表示气球店) 第2行: 共2*N-1)个整数,每两个数描述1个洞口坐标,第ixi,yi表示第i+1层的洞口位置(xi,yi)。 第3行: 共N-1个整数,第i个数为Wi。 往后Q行,每行三个整数x,y,z , 表示第Z层有一个气球店,坐标为(x,y

1个实数L,保留两位小数,表示小X最少要走的长度。

3 10 4 0 0 1 2 9 0 0 1 1 2 3 1 0 1 2 1 1 2

13.00

0

【样例解释】 在第一层从(00)出发到(01)取得1个气球并返回(00)即可到达第二层。长度:2.00 在第二层,从(00)到(01)领取气球,再到(11)领取气球,两个点来回跑,第5次到达(11)时恰好气球数达到10,走到(12)即可到达第3层终点。长度:11.00 总长度:13.00 【数据范围】 2<=N<=100 每层的气球店数目不超过50 0<=M<=100, 0<=Wi<=100 坐标-3000<=x,y<=3000 来源 By Boboo

NOIP2009•Dream Team 模拟赛

2017-04-15 21:09:09

2

256

N

1

1

0

1469

【模拟题】环游世界(travel

Cai0715的世界里,总共有N个城市,每两个城市之间都被一条无向的道路连接。 某一天,BobooCai0715的世界游玩,由于这个世界太过于神奇,使他产生了一种环游世界的冲动,但他必须按照下面的规则进行环游。 他必须在一个城市开始环游,在另一个世界结束环游。 他环游世界时必须经过所有的城市一次,且只能经过一次。 他环游世界时必须经过N-1条道路,且只能经过N-1条道路。 由于某些道路的风景非常漂亮,所以Boboo想要在他环游世界的过程中必须经过这些道路。 现在,给定你一些必须经过的道路,问Boboo环游世界的方案有多少种?

第一行,一个数N,代表共有N个城市。 以下是一个NN列的字符矩阵A,如果A[I][J]Y则代表城市I和城市J之间这条道路必须被经过。

一行,一个数,Boboo环游世界的方案数。由于最后答案可能很大,所以只需要将答案mod 1000000007 输出即可。

3 NYN YNN NNN

4

0

【样例解释】 11->2->3 22->1->3 33->1->2 43->2->1 【数据范围】 对于30%的数据,2<=N<=5。 对于50%的数据,2<=N<=20。 对于100%的数据,2<=N<=50。 来源 By Cai0715

NOIP2009•Dream Team 模拟赛

2017-04-15 21:09:09

2

256

N

1

1

0

1470

【模拟题】H1N1(h1n1)

H1N1来势汹汹,一个区域内的城镇要共同抵御疫情…… 这个区域内共有N座城镇,其中Q个城镇已经建好了防疫站,为了防疫工作的需要,每个城镇必须有公路通到至少一个防疫站,现在已有一些修好的路可以利用。修建第i个城镇到第j个城镇的公路花费cost(ij),还有有P个城镇由于条件优越,可以花钱建防疫站。这N个城镇的人民找到了会编程的你,至少要花多少钱可以完成防疫?

1行: 3个整数 NQP 下来Q行,每行一个整数Ki,表示第K个城镇已有防疫站, 下来P行,每行2个整数Tiprice_i,表示在第Ti个城镇修建防疫站的价格为price_i 以下N*N的矩阵,第i行第j列的整数 表示costij) 最后N*N的矩阵,第i行第j列的整数 第i个城镇与第j个城镇之间的道路有无情况,为0或者11表示已经修建好的,0表示还没有道路。 题目保证2个矩阵都是对称的(a[i,j] = a[j,i])且主对角线都为0a[i,i]=0 , i=1..n)。

1 1个整数ans,表示最少的花费。

3 1 1 1 3 1 0 3 3 3 0 5 3 5 0 0 1 0 1 0 0 0 0 0

1

0

【样例解释】 城镇1已建好防疫站,且1-2有道路已经修好。只需在城镇3建防疫站,花费1. 【数据范围】 对于100%的数据 N<=700 0<=Q,P<=N Cost,price 均为 1-100000 间的整数,题目保证P+Q>0 对于 20% 的数据 P=0,Q=1 对于 30% 的数据 N<=10 来源 By Boboo

NOIP2009•Dream Team 模拟赛

2017-04-15 21:09:09

2

256

N

1

1

0

1471

【动态规划练习】质数取石子

DD  MM 正在玩取石子游戏。他们的游戏规则是这样的:桌上有若干石子,DD 先取,轮流取,每次必须取质数个。如果某一时刻某一方无法从桌上的石子中取质数个,比如说剩下 0 个或 1 个石子,那么他/她就输了。 DD  MM 都很聪明,不管哪方存在一个可以必胜的最优策略,他/她都会按照最优策略保证胜利。于是,DD 想知道,对于给定的桌面上的石子数,他究竟能不能取得胜利呢? 当 DD 确定会取得胜利时,他会说:不管 MM 选择怎样的取石子策略,我都能保证至多 X 步以后就能取得胜利。那么,最小的满足要求的 X 是多少呢?注意,不管是 DD 取一次石子还是 MM 取一次石子都应该被计算为一步

第一行有一个整数 N,表示这个输入文件中包含 N 个测试数据。 第二行开始,每行有一个测试数据,其中仅包含一个整数,表示桌面上的石子数。

你需要对于每个输入文件中的 N 个测试数据输出相应的 N 行。 如果对于该种情形是 DD 一定取得胜利,那么输出最小的 X。否则该行输出 -1

3 8 9 16

1 -1 3

0

样例说明 当桌上有 8 个石子时,先取的 DD 只需要取走 7 个石子剩下 1 个就可以在一步之后保证胜利,输出 1。 当桌上有 9 个石子时。若 DD 取走 2 个,MM 会取走 7 个,剩下 0 个,DD 输。若 DD 取走 3 个,MM 会取走 5 个,剩下 1 个,DD 输。DD 取走 5 个或者 7 个的情况同理可知。所以当桌上有 9 个石子时,不管 DD 怎么取,MM 都可以让 DD 输,输出 -1。 当桌上有 16 个石子时,DD 可以保证在 3 步以内取得胜利。可以证明,为了在 3 步内取得胜利,DD 第一步必须取 7 个石子。剩下 9 个石子之后,不管第二步 MM 怎么取,DD 取了第三步以后可以保证胜利,所以输出 3。 数据范围 输入文件中的数据数 N<=10。 每次桌上初始的石子数都不超过 20000

dd_engi的动态规划专项练习赛

2017-04-15 21:09:09

2

64

N

1

1

0

1472

【动态规划练习】多人背包

DD 和好朋友们要去爬山啦!他们一共有 K 个人,每个人都会背一个包。这些包的容量是相同的,都是 V。可以装进背包里的一共有 N 种物品,每种物品都有给定的体积和价值。 在 DD 看来,合理的背包安排方案是这样的: (1)每个人背包里装的物品的总体积恰等于包的容量。 (2)每个包里的每种物品最多只有一件,但两个不同的包中可以存在相同的物品。 (3)任意两个人,他们包里的物品清单不能完全相同。 在满足以上要求的前提下,所有包里的所有物品的总价值最大是多少呢?

第一行有三个整数:KVN。 第二行开始的 N 行,每行有两个整数,分别代表这件物品的体积和价值。

只需输出一个整数,即在满足以上要求的前提下所有物品的总价值的最大值。

2 10 5 3 12 7 20 2 4 5 6 1 1

57

0

样例说明 一种可以得到最优解的方案是:第一个人背体积为 721 的三种物品,价值为 25。第二个人背体积为 37 的两种物品,价值为 32。总价值 57。 数据范围 总人数 K<=50。 每个背包的容量 V<=5000。 物品种类数 N<=200。 其它正整数都不超过 5000。 输入数据保证存在满足要求的方案。

dd_engi的动态规划专项练习赛

2017-04-15 21:09:09

2

64

N

1

1

0

1473

【动态规划练习】不听话的机器人

DD 有一个不太听话的机器人,这个机器人总是会有自己的想法,而不会完全遵守 DD 给它的指令。 现在 DD 在试图命令机器人走迷宫。迷宫是一个 N*N 个格子组成的区域,格子自左上角到右下角从 (1,1)  (N,N) 编号。第 i 行、第 j 列的格子编号为 (i,j)。迷宫中的某些区域是障碍物,机器人不能移动到那里。 DD 给了机器人 M 条指令,指令的类型包括前进一步”“后退一步”“左转九十度”“右转九十度。但问题是机器人并不能完全遵守这些指令,因为如果机器人完全遵守这些指令,它可能会走到障碍物的格子里或者走到迷宫外面去,那样就会有危险。机器人希望从这个指令序列里面去掉一些,然后执行剩下的指令时,可以保证整个过程中都不会有危险。 机器人虽然不太听话,但它并不想惹恼了 DD,否则 DD 可能会把它拆掉的。所以机器人希望去掉的指令尽量少。 那么,机器人最少需要去掉多少条指令才能保证不会有危险呢?

第一行有四个整数 NMX0Y0。表示迷宫的大小是 N*N,指令共有 M 条,机器人初始时的位置是 (X0,Y0)。机器人初始时面朝的方向是上方。也就是说,若机器人按照初始时的方向走,效果是所在的 X 坐标越来越小。 下面有 N 行,每行有 N 个字符,可能是点号 '.' 或星号 '*''.' 表示空地,'*' 表示障碍。初始位置肯定是一个空地。 下面的 M 行,每行有一个字符串,表示指令。字符串可能是:FORWARD(前进一步)、BACK(后退一步)、LEFT(左转)、RIGHT(右转)。

只需要输出一个整数,表示机器人最少需要去掉多少条指令才能保证不出危险。

4 7 3 3 .*** ..** *..* **** LEFT FORWARD LEFT BACK FORWARD RIGHT FORWARD

1

0

样例说明 去掉第 3 条、第 5 条或者第 7 条指令都可以保证机器人无危险。 数据范围 迷宫的边长 N<=100。 指令数 M<=1000

dd_engi的动态规划专项练习赛

2017-04-15 21:09:09

2

64

N

1

1

0

1474

【动态规划练习】新魔法药水

魔法师 DD 想给 MM 送一份生日礼物,可是他没有足够的金币。魔法娴熟的 DD 自然想到了利用自己高明的魔药配制技巧来多赚一些金币。 DD 一共知道 N 种魔药(以 1..N 编号),还掌握 M 种配制魔药的方法(以 1..M 编号)。他掌握的每种配制魔药的方法都可以简单表述如下:将若干种魔药各一瓶倒入坩埚内,用魔杖搅拌的同时施出一个特定的魔法,再经过适当浓缩,就可以得到一瓶新的魔药。 森林里有一家魔法商店,这里不仅出售各种魔药,同时也以比售价略低的价格收购各种魔药。DD 的如意算盘就是:首先用自己攒下的 V 个金币去魔法商店购买一些魔药作为原料,再用一天的时间在家努力地配制,最后把配制好的成品再卖给魔法商店。 然而,由于魔法修为的原因,DD 在一天之内最多只能施出 K 次魔法。 DD 想让你帮他算一算,他最多能够在这一天时间内赚到多少金币呢?

第一行有四个整数:NMVK。 第二行开始的 N 行,每行有两个整数,第 i+1 行的两个整数分别表示第 i 种魔药的销售价和收购价。 第 N+2 行开始的 M 行,每行有若干个整数,表示 DD 知道的一种魔药配制方法。每行的格式都是这样的:第一个整数表示这种魔药配制方法可以得到的一瓶魔药成品的编号。下一个整数 nn<N),表示这种配制方法需要 n 瓶原料。下面 n 个整数,表示这 n 瓶原料的编号。

只需输出一个整数,表示最多可以赚到金币的数量。

4 2 6 3 1 0 1 0 5 3 20 15 3 2 1 2 4 3 1 2 3

12

0

样例说明 一种最优方案是:买进 1 号和 2 号药水各三瓶,花费 6 金币。使用 1 号魔法 2 次,2 号魔法 1 次。最后得到一瓶 3 号药水,一瓶 4 号药水,卖得 18 金币。赚了 12 金币。 数据范围 药水种类 N<=60。 配制方法数 M<=240。 初始的金币数 V<=1000。 每天可施的魔法数 K<=30

dd_engi的动态规划专项练习赛

2017-04-15 21:09:09

2

64

N

2

2

0

1475

NOIP_2009.TG1:潜伏者

R 国和 S国正陷入战火之中,双方都互派间谍,潜入对方内部,伺机行动。 历尽艰险后,潜伏于 S国的 R 国间谍小 C 终于摸清了 S国军用密码的编码规则: 1 S 国军方内部欲发送的原信息经过加密后在网络上发送,原信息的内容与加密后所得的内容均由大写字母‘A’-‘Z’构成(无空格等其他字符) 。 2 S国对于每个字母规定了对应的密字。加密的过程就是将原信息中的所有字母替换为其对应的密字 3. 每个字母只对应一个唯一的密字,不同的字母对应不同的密字 密字可以和原字母相同。 例如,若规定‘A’的密字为‘A’  ‘B’的密字为‘C’ (其他字母及密字略) ,则原信息“ABA”被加密为“ACA” 。 现在,小 C 通过内线掌握了 S 国网络上发送的一条加密信息及其对应的原信息。小 C希望能通过这条信息,破译 S 国的军用密码。小 C 的破译过程是这样的:扫描原信息,对于原信息中的字母 x(代表任一大写字母) ,找到其在加密信息中的对应大写字母 y,并认为在密码里 y x 的密字。如此进行下去直到停止于如下的某个状态: 1. 所有信息扫描完毕, ‘A’-‘Z’ 所有 26 个字母在原信息中均出现过并获得了相应的密字 2. 所有信息扫描完毕,但发现存在某个(或某些)字母在原信息中没有出现。 3. 扫描中发现掌握的信息里有明显的自相矛盾或错误(违反 S国密码的编码规则) 。例如某条信息“XYZ”被翻译为“ABA”就违反了不同字母对应不同密字的规则。 在小 C 忙得头昏脑涨之际,R 国司令部又发来电报,要求他翻译另外一条从 S 国刚刚截取到的加密信息。现在请你帮助小 C:通过内线掌握的信息,尝试破译密码。然后利用破译的密码,翻译电报中的加密信息。

 3 行,每行为一个长度在 1 100 之间的字符串。 第 1 行为小C 掌握的一条加密信息。 第 2 行为第1 行的加密信息所对应的原信息。 第 3 行为R国司令部要求小 C 翻译的加密信息。 输入数据保证所有字符串仅由大写字母‘A’-‘Z’构成,且第 1 行长度与第 2 行相等。

若破译密码停止时出现 23 两种情况,请你输出“Failed” (不含引号,注意首字母大写,其它小写) 。 否则请输出利用密码翻译电报中加密信息后得到的原信息。

MSRTZCJKPFLQYVAWBINXUEDGHOOILSMIJFRCOPPQCEUNYDUMPP YIZSDWAHLNOVFUCERKJXQMGTBPPKOIYKANZWPLLVWMQJFGQYLL FLSO

NOIP

0

 

NOIP 2009 提高组

2017-04-15 21:09:09

1

128

N

3

3

0

1476

NOIP_2009.TG2:Hankson的趣味题

Hanks 博士是 BT (Bio-Tech,生物技术) 领域的知名专家,他的儿子名叫 Hankson。现在,刚刚放学回家的 Hankson 正在思考一个有趣的问题。 今天在课堂上,老师讲解了如何求两个正整数 c1 c2 的最大公约数和最小公倍数。现在 Hankson 认为自己已经熟练地掌握了这些知识,他开始思考一个求公约数求公倍数之类问题的逆问题,这个问题是这样的:已知正整数 a0,a1,b0,b1,设某未知正整数 x 满足: 1 x  a0 的最大公约数是 a1 2 x b0 的最小公倍数是 b1 Hankson 逆问题就是求出满足条件的正整数 x。但稍加思索之后,他发现这样的x 并不唯一,甚至可能不存在。因此他转而开始考虑如何求解满足条件的 x 的个数。请你帮助他编程求解这个问题。

第一行为一个正整数 n,表示有 n 组输入数据。接下来的 n 行每行一组输入数据,为四个正整数 a0a1b0b1,每两个整数之间用一个空格隔开。输入数据保证 a0能被 a1 整除,b1 能被 b0整除。

n 行。每组输入数据的输出结果占一行,为一个整数。 对于每组数据:若不存在这样的 x,请输出 0; 若存在这样的 x,请输出满足条件的 x 的个数;

2 41 1 96 288 95 1 37 1776

6 2

0

第一组输入数据,x 可以是 9183672144288,共有6个。 第二组输入数据,x 可以是 481776,共有 2 个。 对于 50%的数据,保证有 1≤a0a1b0b1≤10000 n≤100。 对于 100%的数据,保证有 1≤a0a1b0b1≤2,000,000,000 n≤2000

NOIP 2009 提高组

2017-04-15 21:09:09

1

128

N

2

2

0

1477

NOIP_2009.TG3:最优贸易

C 国有 n 个大城市和 m 条道路,每条道路连接这 n 个城市中的某两个城市。任意两个城市之间最多只有一条道路直接相连。这 m 条道路中有一部分为单向通行的道路,一部分为双向通行的道路,双向通行的道路在统计条数时也计为 1 条。 C 国幅员辽阔,各地的资源分布情况各不相同,这就导致了同一种商品在不同城市的价格不一定相同。但是,同一种商品在同一个城市的买入价和卖出价始终是相同的。 商人阿龙来到 C 国旅游。当他得知同一种商品在不同城市的价格可能会不同这一信息之后,便决定在旅游的同时,利用商品在不同城市中的差价赚回一点旅费。设 C  n 个城市的标号从 1~ n,阿龙决定从 1 号城市出发,并最终在 n 号城市结束自己的旅行。在旅游的过程中,任何城市可以重复经过多次,但不要求经过所有 n 个城市。阿龙通过这样的贸易方式赚取旅费:他会选择一个经过的城市买入他最喜欢的商品——水晶球,并在之后经过的另一个城市卖出这个水晶球,用赚取的差价当做旅费。由于阿龙主要是来 C 国旅游,他决定这个贸易只进行最多一次,当然,在赚不到差价的情况下他就无需进行贸易。 假设 C 国有 5 个大城市,城市的编号和道路连接情况如下图,单向箭头表示这条道路为单向通行,双向箭头表示这条道路为双向通行。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/noip/noip2009-3.jpg> 假设 1~n 号城市的水晶球价格分别为 43561。 阿龙可以选择如下一条线路:1->2->3->5,并在 2 号城市以 3 的价格买入水晶球,在 3号城市以 5的价格卖出水晶球,赚取的旅费数为 2。 阿龙也可以选择如下一条线路 1->4->5->4->5,并在第 1 次到达 5 号城市时以 1 的价格买入水晶球,在第 2 次到达 4 号城市时以 6 的价格卖出水晶球,赚取的旅费数为 5。 现在给出 n个城市的水晶球价格,m条道路的信息(每条道路所连接的两个城市的编号以及该条道路的通行情况) 。请你告诉阿龙,他最多能赚取多少旅费。

第一行包含 2 个正整数 n  m,中间用一个空格隔开,分别表示城市的数目和道路的数目。 第二行 n 个正整数,每两个整数之间用一个空格隔开,按标号顺序分别表示这 n 个城市的商品价格。 接下来 m行, 每行有 3 个正整数, x y z, 每两个整数之间用一个空格隔开。 如果 z=1,表示这条道路是城市 x到城市 y之间的单向道路;如果 z=2,表示这条道路为城市 x 和城市y之间的双向道路。

1 行, 包含 1 个整数, 表示最多能赚取的旅费。 如果没有进行贸易,则输出 0

5 5 4 3 5 6 1 1 2 1 1 4 1 2 3 2 3 5 1 4 5 2

5

0

输入数据保证 1 号城市可以到达 n号城市。 对于 10%的数据,1≤n≤6。 对于 30%的数据,1≤n≤100。 对于 50%的数据,不存在一条旅游路线,可以从一个城市出发,再回到这个城市。 对于 100%的数据,1≤n≤1000001≤m≤5000001≤xy≤n1≤z≤21≤各城市水晶球价格≤100

NOIP 2009 提高组

2017-04-15 21:09:09

1

128

N

1

1

0

1478

NOIP_2009.TG4:靶形数独

小城和小华都是热爱数学的好学生,最近,他们不约而同地迷上了数独游戏,好胜的他们想用数独来一比高低。但普通的数独对他们来说都过于简单了,于是他们向 Z博士请教,Z 博士拿出了他最近发明的靶形数独,作为这两个孩子比试的题目。 靶形数独的方格同普通数独一样,在 9 格宽×9 格高的大九宫格中有 9  3 格宽×3 格高的小九宫格(用粗黑色线隔开的) 。在这个大九宫格中,有一些数字是已知的,根据这些数字,利用逻辑推理,在其他的空格上填入 1 9 的数字。每个数字在每个小九宫格内不能重复出现,每个数字在每行、每列也不能重复出现。但靶形数独有一点和普通数独不同,即每一个方格都有一个分值,而且如同一个靶子一样,离中心越近则分值越高。 (如图) <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/noip/noip2009-41.jpg> 上图具体的分值分布是:最里面一格(黄色区域)为 10 分,黄色区域外面的一圈(红色区域)每个格子为 9 分,再外面一圈(蓝色区域)每个格子为 8分,蓝色区域外面一圈(棕色区域)每个格子为 7分,最外面一圈(白色区域)每个格子为 6 分,如上图所示。 比赛的要求是:每个人必须完成一个给定的数独(每个给定数独可能有不同的填法) ,而且要争取更高的总分数。而这个总分数即每个方格上的分值和完成这个数独时填在相应格上的数字的乘积的总和。如图,在以下的这个已经填完数字的靶形数独游戏中,总分数为 2829。游戏规定,将以总分数的高低决出胜负。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/noip/noip2009-42.jpg> 由于求胜心切,小城找到了善于编程的你,让你帮他求出,对于给定的靶形数独,能够得到的最高分数。

一共 9 行。每行 9 个整数(每个数都在 0—9 的范围内) ,表示一个尚未填满的数独方格,未填的空格用“0”表示。每两个数字之间用一个空格隔开。

输出可以得到的靶形数独的最高分数。如果这个数独无解,则输出整数-1

7 0 0 9 0 0 0 0 1 1 0 0 0 0 5 9 0 0 0 0 0 2 0 0 0 8 0 0 0 5 0 2 0 0 0 3 0 0 0 0 0 0 6 4 8 4 1 3 0 0 0 0 0 0 0 0 7 0 0 2 0 9 0 2 0 1 0 6 0 8 0 4 0 8 0 5 0 4 0 1 2

2829

0

40%的数据,数独中非 0数的个数不少于 30 80%的数据,数独中非 0数的个数不少于 26 100%的数据,数独中非 0 数的个数不少于 24

NOIP 2009 提高组

2017-04-15 21:09:09

30

128

N

2

2

0

1479

【高精度】a/b

高精度除法练习

两个高精度数a,b(少于240位),各占一行。

两行,第一行为a/b的商,第二行为a/b的余数。

23 6

3 5

0

 

高精度除法

2017-04-15 21:09:09

1

64

N

3

7

0

1480

【高精度】TJU_P1013:高精度整数去位取最小问题

键盘输入一个高精度的正整数N,去掉其中任意M个数字后剩下的数字按原左右次序将组成一个新的正整数。编程对给定的NM寻找一种方案使得剩下的数字组成的新数最小。 输出组成的新的正整数。(不超过240) 输入数据均不需判错。 如果去掉了某几个位后得到的新整数开头为0,保留0

本题有多组测试数据,每组测试数据占一行。 一个高精度正整数NN不超过240位)一个正整数M(M为不大于N的长度的正整数) N,M由一个空格分开。

新的正整数,每组数据的输出占一行。不要多余的空白

456547 1 456547 2 456547 3 7773359 2 103 1

45547 4547 447 73359 03

0

 

tju1013

2017-04-15 21:09:09

1

64

N

1

1

0

1481

【高精度】数的计数

先输入一个自然数n(n≤3000000),然后对此自然数按照如下方法进行处理 不作任何处理: 2·在它的左边加上一个自然数,但该自然数不能超过原数的一半; 3·加上数后,继续按此规则进行处理,直到不能再而 自然数为止。 例如n=6 6 16 26 126 36 136 所以满足要求的个数为6

包含多个测试数据,每行是一个整数n(1<=n<=3000000)

一个整数,表示解的个数(保证不超过50)

6

6

0

 

NOIP2001普及组第一题

2017-04-15 21:09:09

1

64

N

0

0

0

1482

【高精度】TJU_P1138:多项式乘法

请编程序把含有乘法运算的代数多项式表达式改写成不含乘法的代数多项式。 为简化计算,特做以下约定: (1) 代数多项式表达式中只涉及一个代数符号a (2) 含有乘法运算的代数多项式表达式都是两个不含乘法运算的代数多项式直接相乘的形式,而且这两个参加乘法的代数多项式都用圆括号括起来了。乘法用符号表示,不得省略。 (3) 常数项以外的各项都是ya^x的形式,其中x为该项的系数, 而y是该项的指数。1=x 时,不得简写成ya^,应写成ya^1。 而1=y时,不得简写成a^x,应写成1a^x

输入:每行一个含有乘法的代数多项式表达式。本题有多组数据。

输出:每行输出一个问题的解。要求指数大的项不能出现在指数小的项之后,指数相同的项必须合并同类项。不允许出现不必要的空白字符。

(5a^2+3a^1+2)*(4a^1+1) (5a^1+1)* (5a^1+1)

20a^3+17a^2+11a^1+2 25a^2+10a^1+1

0

 

tju1138

2017-04-15 21:09:09

1

64

N

0

1

0

1483

TJU_P1014:阶乘结果末尾有多少零?

本题有多组测试数据,每组测试数据占一行。 每组数据含有一个正整数N(N不大于1000000)

本题有多组测试数据,每组测试数据占一行。 每组数据含有一个正整数N(N不大于1000000)

输出一个整数,表示N!的末尾有多少个连续的零。

1 5 1000

0 1 249

0

 

toj 1014

2017-04-15 21:09:09

1

64

N

0

1

0

1484

排列与组合:字符串的序号

字符串 acab 含有两个 a ,一个 b ,一个 c , acab 含的字母和每个字母的个数都相等的字符串还有: aacb,baca等,因为他们也是含有两个 a ,一个 b ,一个 c 。所有满足这个性质的字符串按字典顺序排列后, acab 是第 5 个,我们就说 acab 的序号是 5 .再如:ba 的序号是 2,aa 的序号是 1. 编程求出给定字符串 S(长度<=100) 的序号 P(保证<=30000) 注意:字符串只含小写字母。

第一行为一整数N,表示有N组测试数据。每组测试数据为一字符串S

输出P

2 kensta jyms

274 5

0

 

tju 1030

2017-04-15 21:09:09

1

64

N

0

1

0

1485

NOI2009一试:变换序列

对于N个整数0, 1, ……, N-1,一个变换序列T可以将i变成Ti,其中 且 。 ,定义xy之间的距离 。给定每个iTi之间的距离D(i,Ti),你需要求出一个满足要求的变换序列T。如果有多个满足条件的序列,输出其中字典序最小的一个。 说明:对于两个变换序列ST,如果存在p<N,满足对于i=0,1,……p-1Si=TiSp<Tp,我们称ST字典序小。

输入文件transform.in的第一行包含一个整数N,表示序列的长度。接下来的一行包含N个整数Di,其中Di表示iTi之间的距离。

输出文件为transform.out。 如果至少存在一个满足要求的变换序列T,则输出文件中包含一行N个整数,表示你计算得到的字典序最小的T;否则输出”No Answer”(不含引号)。注意:输出文件中相邻两个数之间用一个空格分开,行末不包含多余空格。

5 1 1 2 2 1

1 2 4 0 3

0

【数据规模和约定】 20%的数据中N≤50 60%的数据中N≤500 100%的数据中N≤10000

NOI2009一试:变换序列

2017-04-15 21:09:09

1

64

N

1

1

0

1486

NOI2009一试:诗人小G

G是一个出色的诗人,经常作诗自娱自乐。但是,他一直被一件事情所困扰,那就是诗的排版问题。 一首诗包含了若干个句子,对于一些连续的短句,可以将它们用空格隔开并放在一行中, 注意一行中可以放的句子数目是没有限制的。小G给每首诗定义了一个行标准长度(行的长度为一行中符号的总个数),他希望排版后每行的长度都和行标准长度相差不远。显然排版时,不应改变原有的句子顺序,并且小G不允许把一个句子分在两行或者更多的行内。在满足上面两个条件的情况下,小G对于排版中的每行定义了一个不协调度, 为这行的实际长度与行标准长度差值绝对值的P次方,而一个排版的不协调度为所有行不协调度的总和。 小G最近又作了几首诗,现在请你对这首诗进行排版,使得排版后的诗尽量协调(即不协调度尽量小),并把排版的结果告诉他。

输入文件poet.in包含多组数据。 第一行包含一个整数T,表示诗的数量,接下来是T首诗,这里一首诗即为一组数据。每组数据的第一行包含三个由空格分隔的正整数NLP,其中N表示这首诗句子的数目,L表示这首诗的行标准长度,P的含义见问题描述。从第2行开始,每行为一个句子,句子由英文字母、数字、标点符号等符号组成(ASCII33~127, 但不包含 ‘-’)

输出文件为poet.out。 对于每组数据,若最小的不协调度不超过1018,则第一行一个数表示不协调度,接下来若干行,表示你排版之后的诗。注意:在同一行的相邻两个句子之间需要用一个空格分开。如果有多个可行解,它们的不协调度都是最小值,则输出任意一个解均可。若最小的不协调度超过1018,则输出"Too hard to arrange"(不包含引号)。每组数据结束后输出"--------------------"(不包括引号),共20"-""-"ASCII码为45,请勿输出多余的空行或者空格。

4 4 9 3 brysj, hhrhl. yqqlm, gsycl. 4 9 2 brysj, hhrhl. yqqlm, gsycl. 1 1005 6 poet 1 1004 6 poet

108 brysj, hhrhl. yqqlm, gsycl. -------------------- 32 brysj, hhrhl. yqqlm, gsycl. -------------------- Too hard to arrange -------------------- 1000000000000000000 poet --------------------

0

【样例说明】 前两组输入数据中每行的实际长度均为6,后两组输入数据每行的实际长度均为4。一个排版方案中每行相邻两个句子之间的空格也算在这行的长度中(可参见样例中第二组数据)。每行末尾没有空格。 【评分方法】 本题设有部分分,当你的程序对于该测试点内每组数据计算得出的不协调度最小值都正确时,能得到本测试点70%的分数。在此情况下,若每组数据的排版方案都合法并且得出的不协调度都与输出的相等,则能得到本测试点剩下30%的分数。注意,输出格式错误可能会导致本测试点不得分。 【数据规模和约定】 总共10个测试点,数据范围满足: 测试点 T N L P 1 ≤10 ≤18 ≤100 ≤5 2 ≤10 ≤2000 ≤60000 ≤10 3 ≤10 ≤2000 ≤60000 ≤10 4 ≤5 ≤100000 ≤200 ≤10 5 ≤5 ≤100000 ≤200 ≤10 6 ≤5 ≤100000 ≤3000000 2 7 ≤5 ≤100000 ≤3000000 2 8 ≤5 ≤100000 ≤3000000 ≤10 9 ≤5 ≤100000 ≤3000000 ≤10 10 ≤5 ≤100000 ≤3000000 ≤10 所有测试点中均满足句子长度不超过30

NOI2009一试:诗人小G

2017-04-15 21:09:09

1

64

N

0

2

0

1487

NOI2009一试:二叉查找树

已知一棵特殊的二叉查找树。根据定义,该二叉查找树中每个结点的数据值都比它左子树结点的数据值大,而比它右子树结点的数据值小。 另一方面,这棵查找树中每个结点都有一个权值,每个结点的权值都比它的儿子结点的权值要小。 已知树中所有结点的数据值各不相同;所有结点的权值也各不相同。这时可得出这样一个有趣的结论:如果能够确定树中每个结点的数据值和权值,那么树的形态便可以唯一确定。因为这样的一棵树可以看成是按照权值从小到大顺序插入结点所得到的、按照数据值排序的二叉查找树。 一个结点在树中的深度定义为它到树根的距离加1。因此树的根结点的深度为1。 每个结点除了数据值和权值以外,还有一个访问频度。我们定义一个结点在树中的访问代价为它的访问频度乘以它在树中的深度。整棵树的访问代价定义为所有结点在树中的访问代价之和。 现在给定每个结点的数据值、权值和访问频度,你可以根据需要修改某些结点的权值,但每次修改你会付出K的额外修改代价。你可以把结点的权值改为任何实数,但是修改后所有结点的权值必须仍保持互不相同。现在你要解决的问题是,整棵树的访问代价与额外修改代价的和最小是多少?

输入文件名为treapmod.in。 输入文件第一行包含两个正整数NKN为结点的个数,K为每次修改所需的额外修改代价。 接下来一行包含N个非负整数,是每个结点的数据值。 再接下来一行包含N个非负整数,是每个结点的权值。 再接下来一行包含N个非负整数,是每个结点的访问频度。 所有的数据值、权值、访问频度均不超过400000。每两个数之间都有一个空格分隔,且行尾没有空格。

输出文件名为treapmod.out。输出文件只有一个数字,即你所能得到的整棵树的访问代价与额外修改代价之和的最小值。

4 10 1 2 3 4 1 2 3 4 1 2 3 4

29

0

【样例说明】 输入的原图是左图,它的访问代价是1×1+2×2+3×3+4×4=30。最佳的修改方案是把输入中的第3个结点的权值改成0,得到右图,访问代价是1×2+2×3+3×1+4×2=19,加上额外修改代价10,一共是29。 【数据规模】 40%的数据满足N ≤ 30; 70%的数据满足N ≤ 50; 100%的数据满足N ≤ 70, 1 ≤ K ≤ 30000000

NOI2009一试:二叉查找树

2017-04-15 21:09:09

1

64

N

0

0

0

1488

NOI2009二试:植物大战僵尸

Plants vs. ZombiesPVZ)是最近十分风靡的一款小游戏。Plants(植物)和Zombies(僵尸)是游戏的主角,其中Plants防守,而Zombies进攻。该款游戏包含多种不同的挑战系列,比如Protect Your BrainBowling等等。其中最为经典的,莫过于玩家通过控制Plants来防守Zombies的进攻,或者相反地由玩家通过控制ZombiesPlants发起进攻。 现在,我们将要考虑的问题是游戏中ZombiesPlants的进攻,请注意,本题中规则与实际游戏有所不同。游戏中有两种角色,PlantsZombies,每个Plant有一个攻击位置集合,它可以对这些位置进行保护;而Zombie进攻植物的方式是走到植物所在的位置上并将其吃掉。 游戏的地图可以抽象为一个NM列的矩阵,行从上到下用0N–1编号,列从左到右用0M–1编号;在地图的每个位置上都放有一个Plant,为简单起见,我们把位于第r行第c列的植物记为Pr, c Plants分很多种,有攻击类、防守类和经济类等等。为了简单的描述每个Plant,定义ScoreAttack如下: Score[Pr, c] Zombie击溃植物Pr, c可获得的能源。若Score[Pr, c]为非负整数,则表示击溃植物Pr, c可获得能源Score[Pr, c],若为负数表示击溃Pr, c需要付出能源 -Score[Pr, c] Attack[Pr, c] 植物Pr, c能够对Zombie进行攻击的位置集合。 Zombies必须从地图的右侧进入,且只能沿着水平方向进行移动。Zombies攻击植物的唯一方式就是走到该植物所在的位置并将植物吃掉。因此Zombies的进攻总是从地图的右侧开始。也就是说,对于第r行的进攻,Zombies必须首先攻击Pr, M-1;若需要对Pr, c0≤c<M-1)攻击,必须将Pr,M-1, Pr, M-2 … Pr, c+1先击溃,并移动到位置(r, c)才可进行攻击。 在本题的设定中,Plants的攻击力是无穷大的,一旦Zombie进入某个Plant的攻击位置,该Zombie会被瞬间消灭,而该Zombie没有时间进行任何攻击操作。因此,即便Zombie进入了一个Plant所在的位置,但该位置属于其他植物的攻击位置集合,则Zombie会被瞬间消灭而所在位置的植物则安然无恙(在我们的设定中,Plant的攻击位置不包含自身所在位置,否则你就不可能击溃它了)。 Zombies的目标是对Plants的阵地发起进攻并获得最大的能源收入。每一次,你可以选择一个可进攻的植物进行攻击。本题的目标为,制定一套Zombies的进攻方案,选择进攻哪些植物以及进攻的顺序,从而获得最大的能源收入。

输入文件pvz.in的第一行包含两个整数N, M,分别表示地图的行数和列数。 接下来N×M行描述每个位置上植物的信息。第r×M + c + 1行按照如下格式给出植物Pr, c的信息:第一个整数为Score[Pr, c], 第二个整数为集合Attack[Pr, c]中的位置个数w,接下来w个位置信息(r’, c’),表示Pr, c可以攻击位置第r’ 行第c’ 列。

输出文件pvz.out仅包含一个整数,表示可以获得的最大能源收入。注意,你也可以选择不进行任何攻击,这样能源收入为0

3 2 10 0 20 0 -10 0 -5 1 0 0 100 1 2 1 100 0

25

0

【样例说明】 在样例中, 植物P1,1可以攻击位置(0,0), P2, 0可以攻击位置(2,1)。 一个方案为,首先进攻P1,1, P0,1,此时可以攻击P0,0 。共得到能源收益为(-5)+20+10 = 25。注意, 位置(2,1)被植物P2,0保护,所以无法攻击第2行中的任何植物。 【大致数据规模】 约20%的数据满足1 ≤ N, M ≤ 5; 约40%的数据满足1 ≤ N, M ≤ 10; 约100%的数据满足1 ≤ N ≤ 201 ≤ M ≤ 30-10000 ≤ Score ≤ 10000

NOI2009二试:植物大战僵尸

2017-04-15 21:09:09

1

64

N

1

1

0

1489

NOI2009二试:管道取珠

管道取珠是小X很喜欢的一款游戏。在本题中,我们将考虑该游戏的一个简单改版。游戏画面如图1所示: (1) 游戏初始时,左侧上下两个管道分别有一定数量的小球(有深色球和浅色球两种类型),而右侧输出管道为空。每一次操作,可以从左侧选择一个管道,并将该管道中最右侧的球推入右边输出管道。 例如,我们首先从下管道中移一个球到输出管道中,将得到图2所示的情况。 (2) 假设上管道中有n个球, 下管道中有m个球,则整个游戏过程需要进行n + m次操作,即将所有左侧管道中的球移入输出管道。最终n + m个球在输出管道中从右到左形成输出序列。 爱好数学的小X知道,他共有C(n+m, n)种不同的操作方式,而不同的操作方式可能导致相同的输出序列。举个例子,对于图3所示的游戏情形: (3) 我们用A表示浅色球,B表示深色球。并设移动上管道右侧球的操作为U, 移动下管道右侧球的操作为D,则共有C(2+1,1)=3种不同的操作方式, 分别为UUD, UDU, DUU;最终在输出管道中形成的输出序列(从右到左)分别为BABBBABBA。可以发现后两种操作方式将得到同样的输出序列。 假设最终可能产生的不同种类的输出序列共有K种,其中第i种输出序列的产生方式(即不同的操作方式数目)ai个。聪明的小X早已知道, 因此,小X希望计算得到 你能帮助他计算这个值么?由于这个值可能很大,因此只需要输出该值对1024523的取模即可(即除以1024523的余数)。 说明:文中C(n + m, n)表示组合数。组合数C(a, b)等价于在a个不同的物品中选取b个的选取方案数。

输入文件ball.in第一行包含两个整数n, m,分别表示上下两个管道中球的数目。 第二行为一个AB字符串,长度为n,表示上管道中从左到右球的类型。其中A表示浅色球,B表示深色球。 第三行为一个AB字符串,长度为m,表示下管道中的情形。

输出文件ball.out仅包含一行,即为 除以1024523的余数。

2 1 AB B

5

0

【样例说明】 样例即为文中(3)。共有两种不同的输出序列形式,序列BAB1种产生方式,而序列BBA2种产生方式,因此答案为5。 【大致数据规模】 约30%的数据满足 n, m ≤ 12; 约100%的数据满足n, m ≤ 500

NOI2009二试:管道取珠

2017-04-15 21:09:09

1

64

N

0

0

0

1490

NOI2009二试:描边

Z自幼就酷爱数学。聪明的他特别喜欢研究一些数学小问题。 有一天,小Z在一张纸上选择了n个点,并用铅笔将它们两两连接起来,构成n(n-1)/2条线段。由于铅笔很细,可以认为这些线段的宽度为0。 望着这些线段,小Z陷入了冥想中。他认为这些线段中的一部分比较重要,需要进行强调。因此小Z拿出了毛笔,将它们重新进行了描边。毛笔画在纸上,会形成一个半径为r的圆。在对一条线段进行描边时,毛笔的中心(即圆心)将从线段的一个端点开始,沿着该线段描向另一个端点。下图即为在一张4个点的图中,对其中一条线段进行描边强调后的情况。 现在,小Z非常想知道在描边之后纸面上共有多大面积的区域被强调,你能帮助他解答这个问题么?

这是一道提交答案型试题,所有的输入文件 path1.in~path10.in 已在相应目录下。 输入文件 path*.in 第一行包含一个正整数n,表示选择的点的数目。 第2至第n+1行,第i+1行有两个实数xi, yi,表示点i的坐标为(xi, yi)。 第n+2行有一个正整数m,表示小Z认为比较重要的线段的条数。 第n+3至第n+m+2行,每行有两个正整数a, b表示一条线段。a, b两个数分别表示该线段的两个端点的编号。 第n+m+3行,有一个实数r,表示毛笔在纸上形成的圆的半径。 第n+m+4行,有四个实数p1, p2, p3, p4,为评分使用的参数。

输出文件path*.out仅包含一行,即为描边后被强调区域的总面积。

2 1 1 1 2 1 1 2 1 0.00001 0.001 0.1 1

5.1415927

0

如下图所示。 【评分标准】 每个测试点单独评分。 本题设有4个评分参数p1,p2,p3,p4 (p1< p2 < p3 < p4),已在输入文件中给出。你的得分将按照如下规则给出: 若你的答案与标准答案相差不超过p1,则该测试点你将得到满分; 否则,若你的答案与标准答案相差不超过p2,则你将得到该测试点70%的分数; 否则,若你的答案与标准答案相差不超过p3,则你将得到该测试点40%的分数; 否则,若你的答案与标准答案相差不超过p4,则你将得到该测试点10%的分数; 否则该测试点你的得分为0

NOI2009二试:描边

2017-04-15 21:09:09

1

64

N

0

0

0

1491

01背包:Bone Collector骨骼收集家

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1491.jpg> Many years ago , in Teddy’s hometown there was a man who was called “Bone Collector”. 许多年前,在泰迪镇有这么一个骨骼收集家。 This man like to collect varies of bones , such as dog’s , cow’s , also he went to the grave … 这个人喜欢收集一些骨骼,比如:狗的、牛的、当然也有人骨…… The bone collector had a big bag with a volume of V ,and along his trip of collecting there are a lot of bones , 在他旅途中,他会带上一个体积V的大包,专门用来放置各种收集到的骨骼。 obviously , different bone has different value and different volume, now given the each bone’s value along his trip , 众所周知,不同的骨骼有着不同的收集价值和体积,这一点在其旅途中我们预先给出。 can you calculate out the maximum of the total value the bone collector can get ? 请你计算出骨骼收集家利用他的包,旅途中收集到的最大总价值?

The first line contain a integer T , the number of cases. 1行包含1个整数T,表示测试数据的组数。 Followed by T cases , each case three lines ,接下来有T组测试数据,每组测试数据3行, the first line contain two integer V, N, (V <= 1000 , N <= 1000 )representing the number of bones and the volume of his bag. 1行包含两个整数VN, (V <= 1000 , N <= 1000 ),其中:N表示骨骼的数量,V表示包的体积。 And the second line contain N integers representing the value of each bone. 2行包含N个整数,依次代表N个骨骼每一个骨骼的体积。 第3行包含N个整数,依次代表N个骨骼每一个骨骼的价值。 The third line contain N integers representing the volume of each bone.

One integer per line representing the maximum of the total value (this number will be less than 2^31). 输出一个整数,占一行,表示总价值。(<2^31

1 10 5 1 2 3 4 5 5 4 3 2 1

14

0

Teddy

HDU 1st “Vegetable-Birds Cup” Programming Open Contest

2017-04-15 21:09:09

1

64

N

2

3

0

1492

完全背包:Piggy-Bank猪猪储蓄罐

Before ACM can do anything, a budget must be prepared and the necessary financial support obtained. ACM要正常运转的前提,准备并提供好一定的财务预算费用是必需的。 The main income for this action comes from Irreversibly Bound Money (IBM). 这项活动最主要的收支来自于IBM公司。 The idea behind is simple. Whenever some ACM member has any small money, he takes all the coins and throws them into a piggy-bank. 想法很简单,只要ACM成员有一些散钱,他就可以取出所有钱并将其投放到猪猪储蓄罐中。 You know that this process is irreversible, the coins cannot be removed without breaking the pig. After a sufficiently long time, there should be enough cash in the piggy-bank to pay everything that needs to be paid. 你要知道的是,这项操作是不可以撤销的,这些硬币投入进去之后是没有打碎猪猪是取不出来的。当充分储备一段较长时间后,在猪猪储蓄罐中可能会有足够多的钱来去付我们需要的费用。 But there is a big problem with piggy-banks. It is not possible to determine how much money is inside. So we might break the pig into pieces only to find out that there is not enough money. Clearly, we want to avoid this unpleasant situation. 但是同样也带来了一个大问题。我们没法准确知道猪猪储蓄罐中到底有多少钱。因此我们必须把它打碎才能知道钱是否足够。很显然,我们大家都会尽可能避免这种不愉快的情形。 The only possibility is to weigh the piggy-bank and try to guess how many coins are inside. Assume that we are able to determine the weight of the pig exactly and that we know the weights of all coins of a given currency. 唯一的可能就是去称一称猪猪储蓄罐的重量,然后试着去猜猜它里面到底有多少钱币。假设我们能够确定猪猪储蓄罐准确的重量并知道所有给定的硬币的各个重量。 Then there is some minimum amount of money in the piggy-bank that we can guarantee. Your task is to find out this worst case and determine the minimum amount of cash inside the piggy-bank. We need your help. No more prematurely broken pigs! 因此我们可以保证猪猪储蓄罐中最少数量的钱币。你的任务是找出最糟糕的情况:猪猪储蓄罐中最少可能多少钱,我们需要你的帮助,以免过早地打碎这些猪猪们。

The input consists of T test cases. The number of them (T) is given on the first line of the input file. 输入文件有T组测试数据。数据T在输入文件首行给出。 Each test case begins with a line containing two integers E and F. They indicate the weight of an empty pig and of the pig filled with coins. Both weights are given in grams. No pig will weigh more than 10 kg, that means 1 <= E <= F <= 10000. 每组测试数据,包含两个整数EF。他们分别表示空的猪猪储蓄罐的重量,和装满钱币后的猪猪储蓄罐的重量。两者重量单位为:克。没有任何一个猪猪储蓄罐总重量超出10千克(即:1<=E<=F<=10000 On the second line of each test case, there is an integer number N (1 <= N <= 500) that gives the number of various coins used in the given currency. 每组测试数据的第二行,这儿将有一个整数N (1 <= N <= 500) N指是的当前给定的使用到的硬币的种类。 Following this are exactly N lines, each specifying one coin type. These lines contain two integers each, Pand W (1 <= P <= 50000, 1 <= W <=10000). P is the value of the coin in monetary units, W is it's weight in grams. 接下来是N行,每一行指定的一种硬币。这些行每行均包含两个整数PW(1 <= P <= 50000, 1 <= W <=10000). P是这种硬币的面额,W是这种硬币的重量。

Print exactly one line of output for each test case. 每组输出文件均占一行。 The line must contain the sentence "The minimum amount of money in the piggy-bank is X." where X is the minimum amount of money that can be achieved using coins with the given total weight. If the weight cannot be reached exactly, print a line "This is impossible.". 该行必须包含了内容:"The minimum amount of money in the piggy-bank is X." X是一个整数,指的是使用指定的那些硬币,能够构成总重量,并请输出构成总重量中最小的硬币面额。 如果这种猪猪储蓄罐,给定的钱币总重量是不可能达到的,请输出一行:"This is impossible."

3 10 110 2 1 1 30 50 10 110 2 1 1 50 30 1 6 2 10 3 20 4

The minimum amount of money in the piggy-bank is 60. The minimum amount of money in the piggy-bank is 100. This is impossible.

0

 

Piggy-Bank

2017-04-15 21:09:09

1

64

N

3

3

0

1493

NOIP_2010.PJ1:数字统计

请统计某个给定范围[L, R]的所有整数中,数字 2 出现的次数。 (1≤L≤R≤10000) 比如给定范围[2, 22],数字 2 在数2中出现了 1次,在数 12中出现 1 次,在数 20 中出 现 1 次,在数 21 中出现 1 次,在数 22 中出现 2 次,所以数字 2 在该范围内一共出现了 6 次。

输入文件名为 two.in。 输入共 1 行,为两个正整数 L  R,之间用一个空格隔开。

输出文件名为 two.out。 输出共 1 行,表示数字 2 出现的次数。

2 22 2 100

6 20

0

1≤L≤R≤10000

NOIP_2010.PJ1:数字统计

2018-03-01 15:06:55

1

64

N

0

2

0

2048

[POI2008]激光发射器SZK

<p> //BZOJ1121 </p> <p> 多边形相邻边垂直,边长为整数,边平行坐标轴。要在多边形的点上放一些激光发射器和接收器。满足下列要求: </p> <p> 1发射器和接收器不能放置在同一点; </p> <p> 2发射器发出激光可以沿壁反射,最终到达一个接收器; </p> <p> 3发射器只能沿角平分线发射激光。 </p> <p> 求:最多可放置多少对发射器和接收器?点数4<=n<=100000 </p>

第一行给出一个数字N,代表有多少个点. 下面N,用来描述点的坐标.其值在[-1000000,1000000]

最多可放置多少对发射器和接收器如样例<img src="/JudgeOnline/upload/image/20180301/20180301171014_14869.gif" alt="" />

10 1 1 3 1 3 -2 -3 -2 -3 0 -1 0 -1 -1 2 -1 2 0 1 0

5

0

<span style="line-height:1.5;">一道神奇的题目——想必学过物理竞赛的都该知道光路可逆</span><br />

 

2018-03-18 16:15:08

1

128

N

11

13

0

1494

NOIP_2010.PJ2:接水问题

学校里有一个水房,水房里一共装有 m 个龙头可供同学们打开水,每个龙头每秒钟的供水量相等,均为 1。 现在有 n 名同学准备接水,他们的初始接水顺序已经确定。将这些同学按接水顺序从 1 n 编号,i号同学的接水量为 wi。接水开始时,1  m号同学各占一个水龙头,并同时打开水龙头接水。当其中某名同学 j 完成其接水量要求 wj 后,下一名排队等候接水的同学 k马上接替 j 同学的位置开始接水。这个换人的过程是瞬间完成的,且没有任何水的浪费。即j 同学第x 秒结束时完成接水,则 k 同学第 x+1 秒立刻开始接水。若当前接水人数 n’不足 m,则只有 n’个龙头供水,其它 m-n’个龙头关闭。 现在给出 n名同学的接水量,按照上述接水规则,问所有同学都接完水需要多少秒。

输入文件名为 water.in。 第 1 2 个整数 n  m,用一个空格隔开,分别表示接水人数和龙头个数。 第 2  n 个整数 w1w2……wn,每两个整数之间用一个空格隔开,wi表示 i 号同学的接水量。 (【数据范围】1≤n≤100001≤m≤100  m≤n 1≤wi≤100

输出文件名为 water.out。 输出只有一行,1 个整数,表示接水所需的总时间。

【输入输出样例 1 5 3 4 4 1 2 1 【输入输出样例 2 8 4 23 71 87 32 70 93 80 76

【输入输出样例 1 4 【输入输出样例 2 163

0

【数据范围】 1≤n≤100001≤m≤100  m≤n 1≤wi≤100。 【输入输出样例 1 说明】 第 1 秒,3 人接水。第 1秒结束时,123 号同学每人的已接水量为 13 号同学接完水,4 号同学接替 3 号同学开始接水。 第 2 秒,3 人接水。第 2 秒结束时,12 号同学每人的已接水量为 24 号同学的已接水量为 1。 第 3 秒,3 人接水。第 3 秒结束时,12 号同学每人的已接水量为 34 号同学的已接水量为 24号同学接完水,5 号同学接替 4 号同学开始接水。 第 4 秒,3 人接水。第 4 秒结束时,12 号同学每人的已接水量为 45 号同学的已接水量为 1125 号同学接完水,即所有人完成接水。 总接水时间为 4 秒。

NOIP_2010.PJ2:接水问题

2017-04-15 21:09:09

1

64

N

1

4

0

1495

NOIP_2010.PJ3:导弹拦截

经过 11 年的韬光养晦,某国研发出了一种新的导弹拦截系统,凡是与它的距离不超过其工作半径的导弹都能够被它成功拦截。当工作半径为 0 时,则能够拦截与它位置恰好相同的导弹。但该导弹拦截系统也存在这样的缺陷:每套系统每天只能设定一次工作半径。而当天的使用代价,就是所有系统工作半径的平方和。 某天,雷达捕捉到敌国的导弹来袭。由于该系统尚处于试验阶段,所以只有两套系统投入工作。如果现在的要求是拦截所有的导弹,请计算这一天的最小使用代价。

输入文件名 missile.in。 第一行包含 4 个整数x1y1x2y2,每两个整数之间用一个空格隔开,表示这两套导弹拦截系统的坐标分别为(x1, y1)(x2, y2)。 第二行包含 1 个整数 N,表示有 N颗导弹。接下来 N行,每行两个整数 xy,中间用一个空格隔开,表示一颗导弹的坐标(x, y)。不同导弹的坐标可能相同。

输出文件名 missile.out。 输出只有一行,包含一个整数,即当天的最小使用代价。

【输入输出样例 1 0 0 10 0 2 -3 3 10 0 【样例 1 说明】 样例 1 中要拦截所有导弹,在满足最小使用代价的前提下,两套系统工作半径的平方分别为 18  0。 【输入输出样例 2 0 0 6 0 5 -4 -2 -2 3 4 0 6 -2 9 1 【样例 2 说明】 样例中的导弹拦截系统和导弹所在的位置如下图所示。要拦截所有导弹,在满足最小使用代价的前提下,两套系统工作半径的平方分别为 20  10

【输入输出样例 1 18 【输入输出样例 2 30

0

【提示】 两个点(x1, y1)(x2, y2)之间距离的平方是(x1- x2)^2 +(y1-y2)^2 。 两套系统工作半径 r1r2的平方和,是指 r1r2 分别取平方后再求和,即 r1^2 +r2^2  <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1495.jpg> 【数据范围】 对于 10%的数据,N = 1 对于 20%的数据,1 ≤ N ≤ 2 对于 40%的数据,1 ≤ N ≤ 100 对于 70%的数据,1 ≤ N ≤ 1000 对于 100%的数据,1 ≤ N ≤ 100000,且所有坐标分量的绝对值都不超过 1000

NOIP_2010.PJ3:导弹拦截

2017-04-15 21:09:09

1

64

N

0

2

0

1496

NOIP_2010.PJ4:三国游戏

小涵很喜欢电脑游戏,这些天他正在玩一个叫做《三国》的游戏。 在游戏中,小涵和计算机各执一方,组建各自的军队进行对战。游戏中共有 N位武将(N为偶数且不小于 4),任意两个武将之间有一个默契值,表示若此两位武将作为一对组合作战时,该组合的威力有多大。游戏开始前,所有武将都是自由的(称为自由武将,一旦某个自由武将被选中作为某方军队的一员,那么他就不再是自由武将了),换句话说,所谓的自由武将不属于任何一方。游戏开始,小涵和计算机要从自由武将中挑选武将组成自己的军队,规则如下:小涵先从自由武将中选出一个加入自己的军队,然后计算机也从自由武将中选出一个加入计算机方的军队。接下来一直按照小涵计算机小涵→……”的顺序选择武将,直到所有的武将被双方均分完。然后,程序自动从双方军队中各挑出一对默契值最高的武将组合代表自己的军队进行二对二比武,拥有更高默契值的一对武将组合获胜,表示两军交战,拥有获胜武将组合的一方获胜。 已知计算机一方选择武将的原则是尽量破坏对手下一步将形成的最强组合,它采取的具体策略如下:任何时刻,轮到计算机挑选时,它会尝试将对手军队中的每个武将与当前每个自由武将进行一一配对,找出所有配对中默契值最高的那对武将组合,并将该组合中的自由武将选入自己的军队。 下面举例说明计算机的选将策略,例如,游戏中一共有 6个武将,他们相互之间的默契值如下表所示: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1496_1.jpg> 双方选将过程如下所示: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1496_2.jpg> 小涵想知道,如果计算机在一局游戏中始终坚持上面这个策略,那么自己有没有可能必胜?如果有,在所有可能的胜利结局中,自己那对用于比武的武将组合的默契值最大是多少? 假设整个游戏过程中,对战双方任何时候均能看到自由武将队中的武将和对方军队的武将。为了简化问题,保证对于不同的武将组合,其默契值均不相同。

输入文件名为 sanguo.in,共 N行。 第一行为一个偶数 N,表示武将的个数。 第 2 行到第 N 行里,第(i+1)行有(N-i)个非负整数,每两个数之间用一个空格隔开,表示 i 号武将和 i+1i+2……N号武将之间的默契值(0≤默契值≤1,000,000,000)。 【数据范围】 对于 40%的数据有 N≤10。 对于 70%的数据有 N≤18。 对于 100%的数据有 N≤500

输出文件 sanguo.out  1 2 行。 若对于给定的游戏输入,存在可以让小涵获胜的选将顺序,则输出 1,并另起一行输出所有获胜的情况中,小涵最终选出的武将组合的最大默契值。 如果不存在可以让小涵获胜的选将顺序,则输出 0

【输入输出样例 1 6 5 28 16 29 27 23 3 20 1 8 32 26 33 11 12 【输入输出样例 2 8 42 24 10 29 27 12 58 31 8 16 26 80 6 25 3 36 11 5 33 20 17 13 15 77 9 4 50 19

【输入输出样例 1 1 32 【输入输出样例1说明】 首先小涵拿走 5 号武将; 计算机发现 5 号武将和剩下武将中的 4 号默契值最高,于是拿走 4 号; 小涵接着拿走 3 号; 计算机发现 35 号武将之一和剩下的武将配对的所有组合中,5 号和1 号默契值最高,于是拿走 1号; 小涵接着拿走 2 号; 计算机最后拿走 6 号。 在小涵手里的 235 号武将中,3 号和 5 号配合最好,默契值为 32,而计算机能推出的最好组合为 1 号和 6 号,默契值为 27。 结果为小涵胜,并且这个组合是小涵用尽所有方法能取到的最好组合。 【输入输出样例 2 1 77

0

【数据范围】 对于 40%的数据有 N≤10。 对于 70%的数据有 N≤18。 对于 100%的数据有 N≤500

NOIP_2010.PJ4:三国游戏

2017-04-15 21:09:09

1

64

N

0

1

0

1497

NOIP_2010.TG1:机器翻译

小晨的电脑上安装了一个机器翻译软件,他经常用这个软件来翻译英语文章。 这个翻译软件的原理很简单,它只是从头到尾,依次将每个英文单词用对应的中文含义来替换。对于每个英文单词,软件会先在内存中查找这个单词的中文含义,如果内存中有,软件就会用它进行翻译;如果内存中没有,软件就会在外存中的词典内查找,查出单词的中文含义然后翻译,并将这个单词和译义放入内存,以备后续的查找和翻译。 假设内存中有 M 个单元,每单元能存放一个单词和译义。每当软件将一个新单词存入内存前,如果当前内存中已存入的单词数不超过 M-1,软件会将新单词存入一个未使用的内存单元;若内存中已存入 M 个单词,软件会清空最早进入内存的那个单词,腾出单元来, 存放新单词。 假设一篇英语文章的长度为 N个单词。给定这篇待译文章,翻译软件需要去外存查找多少次词典?假设在翻译开始前,内存中没有任何单词。

输入文件名为 translate.in,输入文件共 2 行。每行中两个数之间用一个空格隔开。 第一行为两个正整数 M N,代表内存容量和文章的长度。 第二行为 N 个非负整数,按照文章的顺序,每个数(大小不超过 1000)代表一个英文单词。文章中两个单词是同一个单词,当且仅当它们对应的非负整数相同。 【数据范围】 对于 10%的数据有 M=1N≤5。 对于 100%的数据有 0<M≤1000<N≤1000

输出文件 translate.out 1行,包含一个整数,为软件需要查词典的次数。

【输入输出样例 1 3 7 1 2 1 5 4 4 1 【输入输出样例 2 2 10 8 824 11 78 11 78 11 78 8 264

【输入输出样例 1 5 【输入输出样例 1 说明】 整个查字典过程如下:每行表示一个单词的翻译,冒号前为本次翻译后的内存状况: 空:内存初始状态为空。 1 1:查找单词1 并调入内存。 2 1 2:查找单词 2 并调入内存。 3 1 2:在内存中找到单词 1 4 1 2 5:查找单词 5 并调入内存。 5 2 5 4:查找单词 4 并调入内存替代单词 1 6 2 5 4:在内存中找到单词 4 7 5 4 1:查找单词 1 并调入内存替代单词 2。 共计查了 5次词典。 【输入输出样例 2 6

0

【数据范围】 对于 10%的数据有 M=1N≤5。 对于 100%的数据有 0<M≤1000<N≤1000

NOIP_2010.TG1:机器翻译

2017-04-15 21:09:09

1

64

N

32

57

0

1498

NOIP_2010.TG2:乌龟棋

小明过生日的时候,爸爸送给他一副乌龟棋当作礼物。 乌龟棋的棋盘是一行 N个格子,每个格子上一个分数(非负整数)。棋盘第 1 格是唯一的起点,第 N格是终点,游戏要求玩家控制一个乌龟棋子从起点出发走到终点。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1498_1.jpg> 乌龟棋中 M 张爬行卡片,分成 4 种不同的类型(M 张卡片中不一定包含所有 4 种类型的卡片,见样例),每种类型的卡片上分别标有 1234 四个数字之一,表示使用这种卡片后,乌龟棋子将向前爬行相应的格子数。游戏中,玩家每次需要从所有的爬行卡片中选择一张之前没有使用过的爬行卡片,控制乌龟棋子前进相应的格子数,每张卡片只能使用一次游戏中,乌龟棋子自动获得起点格子的分数,并且在后续的爬行中每到达一个格子,就得到该格子相应的分数。玩家最终游戏得分就是乌龟棋子从起点到终点过程中到过的所有格子的分数总和。 很明显,用不同的爬行卡片使用顺序会使得最终游戏的得分不同,小明想要找到一种卡片使用顺序使得最终游戏得分最多。 现在,告诉你棋盘上每个格子的分数和所有的爬行卡片,你能告诉小明,他最多能得到多少分吗?

输入文件名 tortoise.in。输入文件的每行中两个数之间用一个空格隔开。 第 1 2 个正整数 N M,分别表示棋盘格子数和爬行卡片数。 第 2  N个非负整数,a1, a2, ……, aN,其中 ai 表示棋盘第 i 个格子上的分数。 第 3 M 个整数,b1,b2, ……, bM,表示 M 张爬行卡片上的数字。 输入数据保证到达终点时刚好用光 M 张爬行卡片, 即 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1498_2.jpg>

输出文件名 tortoise.out。 输出只有 1行,1 个整数,表示小明最多能得到的分数。

【输入输出样例 1 9 5 6 10 14 2 8 8 18 5 17 1 3 1 2 1 【输入输出样例 2 13 8 4 96 10 64 55 13 94 53 5 24 89 8 30 1 1 1 1 1 2 4 1

【输入输出样例 1 73 【输入输出样例 1 说明】 小明使用爬行卡片顺序为 11312,得到的分数为 6+10+14+8+18+17=73。注意,由于起点是 1,所以自动获得第 1 格的分数 6。 【输入输出样例 2 455

0

【数据范围】 对于 30%的数据有 1≤N≤301≤M≤12。 对于 50%的数据有 1≤N≤1201≤M≤50,且 4 种爬行卡片,每种卡片的张数不会超过 20。 对于 100%的数据有 1≤N≤3501≤M≤120,且 4 种爬行卡片,每种卡片的张数不会超过 40 0≤ai≤1001≤i≤N1≤bi≤41≤i≤M。 输入数据保证 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1498_2.jpg>

NOIP_2010.TG2:乌龟棋

2017-04-15 21:09:09

1

64

N

9

9

0

1499

NOIP_2010.TG3:关押罪犯

S城现有两座监狱,一共关押着 N名罪犯,编号分别为 1~N。他们之间的关系自然也极不和谐。很多罪犯之间甚至积怨已久,如果客观条件具备则随时可能爆发冲突。我们用怨气值(一个正整数值)来表示某两名罪犯之间的仇恨程度,怨气值越大,则这两名罪犯之间的积怨越多。如果两名怨气值为 c 的罪犯被关押在同一监狱,他们俩之间会发生摩擦,并造成影响力为 c 的冲突事件。 每年年末,警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表,然后上报到 S  Z 市长那里。公务繁忙的 Z 市长只会去看列表中的第一个事件的影响力,如果影响很坏,他就会考虑撤换警察局长。 在详细考察了 N 名罪犯间的矛盾关系后,警察局长觉得压力巨大。他准备将罪犯们在两座监狱内重新分配,以求产生的冲突事件影响力都较小,从而保住自己的乌纱帽。假设只要处于同一监狱内的某两个罪犯间有仇恨,那么他们一定会在每年的某个时候发生摩擦。那么,应如何分配罪犯,才能使 Z 市长看到的那个冲突事件的影响力最小?这个最小值是多少?

输入文件名为 prison.in。输入文件的每行中两个数之间用一个空格隔开。 第一行为两个正整数 N M,分别表示罪犯的数目以及存在仇恨的罪犯对数。 接下来的 M行每行为三个正整数 ajbjcj,表示 aj号和 bj号罪犯之间存在仇恨,其怨气值为 cj。数据保证1≤aj <bj ≤ N 0<cj ≤1,000,000,000,且每对罪犯组合只出现一次。

输出文件 prison.out 1 行,为 Z 市长看到的那个冲突事件的影响力。 如果本年内监狱中未发生任何冲突事件,请输出 0

4 6 1 4 2534 2 3 3512 1 2 28351 1 3 6618 2 4 1805 3 4 12884

3512 【输入输出样例说明】 罪犯之间的怨气值如下面左图所示,右图所示为罪犯的分配方法,市长看到的冲突事件影响力是 3512(由2 号和3 号罪犯引发)。其他任何分法都不会比这个分法更优。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1499_1.jpg> 【数据范围】 对于 30%的数据有 N≤15。 对于 70%的数据有 N≤2000M≤50000。 对于 100%的数据有 N≤20000M≤100000

0

 

NOIP_2010.TG3:关押罪犯

2017-04-15 21:09:09

1

64

N

1

7

0

1500

NOIP_2010.TG4:引水入城

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1500_1.jpg> 在一个遥远的国度,一侧是风景秀美的湖泊,另一侧则是漫无边际的沙漠。该国的行政区划十分特殊,刚好构成一个 N M 列的矩形,如上图所示,其中每个格子都代表一座城市,每座城市都有一个海拔高度。 为了使居民们都尽可能饮用到清澈的湖水,现在要在某些城市建造水利设施。水利设施有两种,分别为蓄水厂和输水站。蓄水厂的功能是利用水泵将湖泊中的水抽取到所在城市的蓄水池中。因此,只有与湖泊毗邻的第 1 行的城市可以建造蓄水厂。而输水站的功能则是通过输水管线利用高度落差,将湖水从高处向低处输送。故一座城市能建造输水站的前提,是存在比它海拔更高且拥有公共边的相邻城市,已经建有水利设施。 由于第 N 行的城市靠近沙漠,是该国的干旱区,所以要求其中的每座城市都建有水利设施。那么,这个要求能否满足呢?如果能,请计算最少建造几个蓄水厂;如果不能,求干旱区中不可能建有水利设施的城市数目。

输入文件名为 flow.in。输入文件的每行中两个数之间用一个空格隔开。 输入的第一行是两个正整数 N M,表示矩形的规模。 接下来 N行,每行 M 个正整数,依次代表每座城市的海拔高度。

输出文件名为 flow.out。 输出有两行。 如果能满足要求,输出的第一行是整数 1,第二行是一个整数,代表最少建造几个蓄水厂; 如果不能满足要求,输出的第一行是整数 0,第二行是一个整数,代表有几座干旱区中的城市不可能建有水利设施。

【输入输出样例 1 2 5 9 1 5 4 3 8 7 6 1 2 【输入输出样例 2 3 6 8 4 5 6 4 4 7 3 4 3 3 3 3 2 2 1 1 2

【输入输出样例 1 1 1 【样例 1 说明】 只需要在海拔为 9 的那座城市中建造蓄水厂,即可满足要求。 【输入输出样例 2 1 3 【样例 2 说明】 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1500_2.jpg> 上图中,在 3 个粗线框出的城市中建造蓄水厂,可以满足要求。以这 3个蓄水厂为源头在干旱区中建造的输水站分别用 3种颜色标出。当然,建造方法可能不唯一。

0

【数据范围】 本题共有 10个测试数据,每个数据的范围如下表所示: <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1500_3.jpg> 对于所有的 10 个数据,每座城市的海拔高度都不超过 10^6

NOIP_2010.TG4:引水入城

2017-04-15 21:09:09

1

64

N

0

1

0

1501

【其它】V1004伊甸园日历游戏

AdamEve玩一个游戏,他们先从1900.1.12001.11.4这个日期之间随意抽取一个日期出来。然后他们轮流对这个日期进行操作: 1 : 把日期的天数加1,例如1900.1.1变到1900.1.2 2 : 把月份加1,例如:1900.1.1变到1900.2.1 其中如果天数超过应有天数则日期变更到下个月的第1天。月份超过12则变到下一年的1月。而且进行操作二的时候,如果有这样的日期:1900.1.31,则变成了1900.2.31,这样的操作是非法的,我们不允许这样做。而且所有的操作均要考虑历法和闰年的规定。 谁先将日期变到2001.11.4谁就赢了。 每次游戏都是Adam先操作,问他有没有必胜策略?

一个测试点。多组数据。 第一行为数据组数。 接下来一行X Y Z表示XYZ

输出“YES”or“NO”表示亚当是否有必胜策略。

3 2001 11 3 2001 11 2 2001 10 3

YES NO NO

0

建议先把所有情况都算出来^_^

From ZJU

2017-04-15 21:09:09

1

64

N

0

1

0

1502

【其它】V1005超长数字串

George很喜欢数学,尤其是算数数系列。 他最喜欢的是数字的无穷序列,结果是把所有的自然数按升序排列。这个序列开始是: 1234567891011121314... 我们叫序列 S。然后 S[1] = 1, S[2] = 2, ... , S[10] = 1, S[11] = 0, ... , 以此类推。 George 现有一个数字系列 A ,他想知道在S中最早出现的位置。帮助他解决这个难题。

输入文件包含 A - 给出的数字系列。位数不超过 200。没有空格。

输出一个整数。- 最小的 k ,使 A[1] = S[k], A[2] = S[k+1], ... A[len(A)] = S[k + len(A) 1], len(A) 表示 A 的长度。

101

10

0

 

Ural State University Problem Archive

2017-04-15 21:09:09

1

64

N

1

1

0

1503

【其它】V1006 晴天小猪历险记之Hill 

  在很久很久以前,有一个动物村庄,那里是猪的乐园(^_^),村民们勤劳、勇敢、善良、团结……   不过有一天,最小的小小猪生病了,而这种病是极其罕见的,因此大家都没有储存这种药物。所以晴天小猪自告奋勇,要去采取这种药草。于是,晴天小猪的传奇故事便由此展开…… 这一天,他来到了一座深山的山脚下,因为只有这座深山中的一位隐者才知道这种药草的所在。但是上山的路错综复杂,由于小小猪的病情,晴天小猪想找一条需时最少的路到达山顶,但现在它一头雾水,所以向你求助。   山用一个三角形表示,从山顶依次向下有1段、2段、3段等山路,每一段用一个数字T1<=T<=100)表示,代表晴天小猪在这一段山路上需要爬的时间,每一次它都可以朝左、右、左上、右上四个方向走(**注意**:在任意一层的第一段也可以走到本层的最后一段或上一层的最后一段)。   晴天小猪从山的左下角出发,目的地为山顶,即隐者的小屋。

第一行有一个数n2<=n<=1000),表示山的高度。 从第二行至第n+1行,第i+1行有i个数,每个数表示晴天小猪在这一段山路上需要爬的时间。

一个数,即晴天小猪所需要的最短时间。

5 1 2 3 4 5 6 10 1 7 8 1 1 4 5 6

10

0

在山的两侧的走法略有特殊,请自己模拟一下,开始我自己都弄错了……

Sunnypig

2017-04-15 21:09:09

1

64

N

1

1

0

1504

【其它】V1007 绕钉子的长绳子 

平面上有N个圆柱形的大钉子,半径都为R,所有钉子组成一个凸多边形。 现在你要用一条绳子把这些钉子围起来,绳子直径忽略不计。 求出绳子的长度

1行两个数:整数N(1<=N<=100)和实数R。 接下来N行按逆时针顺序给出N个钉子中心的坐标 坐标的绝对值不超过100

一个数,绳子的长度,精确到小数点后2位。

4 1 0.0 0.0 2.0 0.0 2.0 2.0 0.0 2.0

14.28

0

如果你用比较复杂的方法AC了,请想一想有没有更加简便的方法。

Ural

2017-04-15 21:09:09

1

64

N

1

1

0

1505

【数论/数值】V1009 清帝之惑之康熙

康熙是中国历史乃至世界历史中最伟大的帝王之一,清除螯拜,撤除三藩,统一台湾,平定准葛尔叛乱;与此同时,出众的他也被世界各国遣清使臣所折服。康熙是历史上少有的全人,不仅文武兼得,而且在各各方面都有见地,比如说航海、数学、英语、构图、建筑等等。一个最好的例子可以证明:康熙当年演算代数题的草稿纸至今仍然保存完好。   话说康熙掌权之后,每天都抽空做数学题,特别是无聊题。这些天,某某老师开始教他做一些奇怪的题目。在第一节课的时候,老师就问了康熙一个超BT的题目: 话说西汉时期,汉武帝刘彻派遣张骞出使西域,欲同月氏国结交而共驱匈奴。同时,月氏国也欲同大汉结交,也派出使者康破伦出使大汉,可是因为月氏国对于大汉的认知甚少,康破伦同样向西出使大汉。一开始,张骞从大汉出发,康破伦从月氏国出发,两人都在同一纬度线上,张骞所处的经度为x,康破伦所处的经度为y;接下来,两人同时向西走,而且只能向西走,张骞每天走m公里,康破伦每天走n公里,且每天走路的速度不变,也不停下来休息;这样两人就在这一条长为L的纬度线上一直向西走。问:过了多少天之后张骞和康破伦会碰面,并磋商两国结交之事(所谓碰面,是指两人处在同一经度上)。   这下,康熙犯难了,他还是个不大的青年,怎么可能做得出这么难的题目;但是,他又是统领全国的帝皇,怎么能在老师面前丢这么大一个面子。康熙想:不行!一定得把这个题做出来!(然后就有了下面这段记录)   第一天,……   第二天,…………   第三天,………………   第四天,……………………   第五天,…………………………   第六天,………………………………   第七天,……………………………………!!!!!!!   啊!第七天,康熙终于打了7个感叹号,得出了一个重要的结论!!!!!那就是——做不出来。(汗),没办法,他只有请教你,他的挚友,帮他解决这一难题。康熙答应你,如果你把这一题做出来了,你将得到御赐赏银一万万两!$$$$$$$$-$$$$$$$$。为了改变你生活的现状——衣衫褴褛、闻鼠起舞、蟑螂为伴,你下定了决心——我一定得把这题解决!

输入只包括一行5个整数xymnL 其中0<x≠y < =20000000000 < mn < =20000000000 < L < =2100000000

输出碰面所需要的天数,如果永远不可能碰面则输出一行"Impossible"

1 2 3 4 5

4

0

 

From PKU 1061

2017-04-15 21:09:09

2

64

N

1

2

0

1506

【其它】V1010清帝之惑之乾隆

乾隆,雍正的第四子,在位60年,退位后又当了三年太上皇,终年89岁。   乾隆即位之初,实行宽猛互济的政策,务实足国,重视农桑,停止捐纳,平定叛乱等一系列活动中,充分体现了他的文治武功,乾隆帝向慕风雅,精于骑射,笔墨留于大江南北,并是一个有名的文物收藏家。清宫书画大多是他收藏的,他在位期间编纂的《四库全书》共收书3503种,79337卷,36304册,其卷数是《永乐大典》的三倍,成为我国古代思想文化遗产的总汇。   乾隆好游江南,喜欢江南的山水,喜欢江南的人文,喜欢江南的才气,同时他也喜欢江南的汉族美女。 话说乾隆带着他的宰相刘罗锅和你出巡江南,被杭州城府邀请去听戏,至于什么戏,那就不知了。乾隆很高兴,撒酒与君臣共享。三更欲回住处,可是乾隆这人挺怪,他首先要到西湖边散散步,而且命令不准有人跟着他。   小醉,步于西湖岸,停于断桥前,突闻琴声悠悠,歌儿婉婉。这乐曲不哀伤不愁怅,少了一分怨女的羁绊,多了一分少女的期盼。乾隆走上前去,视其背影,为一女子手抚古琴,悠悠而唱。可是这么晚了,小女怎么还不回家呢,莫非是她起早床?乾隆走上前去,小声问道:伊为何未宿?,小女沉默片刻,转身而来。顿时,顿时,顿时!!!!!乾隆惊呆了!!!!哇!!!!噻!!!!!!这人,这伊!!!!原来!!!!!!!不是一个美女(狂汗ing)。小女并未回答她的话,只是与乾隆侃了侃诗。乾隆兴哉,问其曰:不知偶能助伊否?,小女曰:偶无所以助,且有一事相求,愿君能解之。  乾隆一看,立刻晕到在地,片刻而起,曰:明日必解之,且去。   回到家中,乾隆夜召你入寝,曰:如此姑娘,如此情调,如此罗曼蒂克,竟然丢一个如此煞风景之问,一边发气,一边把这个问题交给你。你一看,顿然发现,原来是用蝌蚪文写的:   Problems involving the computation of exact values of very large magnitude and precision are common. For example, the computation of the national debt is a taxing experience for many computer systems.   This problem requires that you write a program to compute the exact value of Rn where R is a real number ( 0.0 < R <= 9999.9) and n is an integer such that 0 < n <= 200.   此时的你,已经是皇帝身边的小太监,自然有必要为皇上解决此题。

The input will consist of a set (less than 11) of pairs of values for R and n. The R value will occupy columns 1 through 6, and the n value will be in columns 8 and 9.

The output will consist of one line for each line of input giving the exact value of R^n. Leading zeros should be suppressed in the output. Insignificant trailing zeros must not be printed. Don't print the decimal point if the result is an integer.

95.123 2 0.4321 5 5.1234 7 6.7592 3 98.999 5 1.0100 10

9048.385129 .01506334182914325601 92663.3181348508776705891407804544 308.806114738688 9509420210.697891990494999 1.10462212541120451001

0

 

Vivian Snow

2017-04-15 21:09:09

2

64

N

0

1

0

1507

【动态规划】V1011 清帝之惑之顺治

  顺治帝福临,是清朝入关后的第一位皇帝。他是皇太极的第九子,生于崇德三年(1638)崇德八年八月二ten+six日在沈阳即位,改元顺治,在位18年。卒于顺治十八年(1661),终24岁。   顺治即位后,由叔父多尔衮辅政。顺治七年,多尔衮出塞射猎,死于塞外。14岁的福临提前亲政。顺治帝天资聪颖,读书勤奋,他吸收先进的汉文化,审时度势,对成法祖制有所更张,且不顾满洲亲贵大臣的反对,倚重汉官。为了使新兴的统治基业长治久安,他以明之兴亡为借鉴,警惕宦官朋党为祸,重视整饬吏治,注意与民休息,取之有节。但他少年气盛,刚愎自用,急噪易怒,当他宠爱的董妃去世后,转而消极厌世,终于匆匆走完短暂的人生历程,英年早逝。他是清朝历史上唯一公开归依禅门的皇帝。   顺治喜欢滑雪,这并不奇怪, 因为滑雪的确很刺激。可是为了获得速度,滑的区域必须向下倾斜,而且当你滑到坡底,你不得不再次走上坡或者等待太监们来载你。顺治想知道载一个区域中最长的滑坡。   区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子:    1 2 3 4 5   16 17 18 19 6   15 24 25 20 7   14 23 22 21 8   13 12 11 10 9   顺治可以从某个点滑向上下左右相邻四个点之一,当且仅当高度减小。在上面的例子中,一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上,这是最长的一条。

输入的第一行表示区域的行数R和列数C(1 <= R,C <= 500)。下面是R行,每行有C个整数,代表高度h0<=h<=10000

输出最长区域的长度。

5 5 1 2 3 4 5 16 17 18 19 6 15 24 25 20 7 14 23 22 21 8 13 12 11 10 9

25

0

 

Vivian Snow

2017-04-15 21:09:09

2

64

N

1

1

0

1508

【计算几何】V1012 清帝之惑之雍正

  雍正帝胤祯,生于康熙十七年(1678)是康熙的第四子。康熙61年,45岁的胤祯继承帝位,在位13年,死于圆明园。庙号世宗。   胤祯是在康乾盛世前期--康熙末年社会出现停滞的形式下登上历史舞台的。复杂的社会矛盾,为胤祯提供了施展抱负和才干的机会。他有步骤地进行了多项重大改革,高瞻远瞩,又惟日孜孜,励精图治,十三年中取得了卓有成效的业绩,为后代的乾隆打下了扎实雄厚的基础,使康乾盛世在乾隆时期达到了顶峰。他的历史地位,同乃父康熙和乃子乾隆相比,毫不逊色。尽管他猜忌多疑,刻薄寡恩,统治严酷,但比起他的业绩来,毕竟是次要的。   话说雍正为了实施促进城市间沟通的政策,他计划在所有的大城市里挑选两个城市,在两个城市之间修建一条运河,这条运河要求是笔直的,以加强这两个城市的经济往来。但雍正希望这条运河长度越短越好,他请来了宰相和大学士帮他解决这个问题——到底挑哪两个大城市,在其间建造运河,使得其长度最小,最小为多少?可是经过长时间的计算和判断,仍然没有得出结果。此时,雍正想到了当初为康熙解决难题的你,是如此的智慧,如此的聪明绝顶。他亲自来到茅厕,找到了你(你当时已然是一个扫厕所的了),希望你能帮他解决这个问题,必定谢。你欣然答应了。   雍正将大致的情况告诉了你,并且说:大清一共有n个大城市,所有的大城市都不在同一个地点,同时我们对这n个城市从1n进行编号;对于一个城市k,他有两个属性,一个是Xk,一个是Yk,分别表示这个城市所处的经度和纬度。请你告诉他问题的结果:L,即运河长度。(你可以假定地球是平面的)

1行,一个整数n。    从第2行到n+1行,按照i从小到大顺序,每行两个整数XiYi,代表编号为i的城市的经度和纬度。    其中2<=n <=1000001<=Xi,Yi<2^31

一个实数L(保留三位小数)。

2 1 1 2 2

1.414

0

 

Vivian Snow

2017-04-15 21:09:09

5

64

N

0

1

0

1509

【计算几何】V1013 墙 就是强

在一个长宽均为10,入口出口分别为(05)、(105)的房间里,有几堵墙,每堵墙上有两个缺口,求入口到出口的最短路经。

第一排为n(n<=20),墙的数目。 接下来n排,每排5个实数xa1b1a2b2 x表示墙的横坐标(所有墙都是竖直的),a1-b1a2-b2之间为空缺。 a1b1a2b2保持递增,x1-xn也是递增的。

输出最短距离,保留2位小数。

2 4 2 7 8 9 7 3 4.5 6 7

10.06

0

 

Tsuzuki Matsumoto From ZJU

2017-04-15 21:09:09

1

64

N

1

1

0

1510

【动态规划】V1014 旅行商简化版

欧几里德旅行商(Euclidean Traveling Salesman)问题也就是货郎担问题一直是困扰全世界数学家、计算机学家的著名问题。现有的算法都没有办法在确定型机器上在多项式时间内求出最优解,但是有办法在多项式时间内求出一个较优解。 为了简化问题,而且保证能在多项式时间内求出最优解,J.L.Bentley提出了一种叫做bitonic tour的哈密尔顿环游。它的要求是任意两点(a,b)之间的相互到达的代价dist(a,b)=dist(b,a)且任意两点之间可以相互到达,并且环游的路线只能是从最西端单向到最东端,再单项返回最西端,并且是一个哈密尔顿回路。 著名的NPC难题的简化版本 现在笛卡尔平面上有n(n<=1000)个点,每个点的坐标为(x,y)(-2^31<x,y<2^31,且为整数),任意两点之间相互到达的代价为这两点的欧几里德距离,现要你编程求出最短bitonic tour

第一行一个整数n 接下来n行,每行两个整数x,y,表示某个点的坐标。 输入中保证没有重复的两点, 保证最西端和最东端都只有一个点。

一行,即最短回路的长度,保留2位小数。

7 0 6 1 0 2 3 5 4 6 1 7 5 8 2

25.58

0

 

《算法导论(第二版)》 15-1

2017-04-15 21:09:09

1

64

N

1

2

0

1511

【动态规划】V1015 十字绣

考古学家发现了一块布,布上做有针线活,叫做十字绣,即交替地在布的两面穿线。 布是一个n*m的网格,线只能在网格的顶点处才能从布的一面穿到另一面。每一段线都覆盖一个单位网格的两条对角线之一,而在绣的过程中,一针中连续的两段线必须分处布的两面。给出布两面的图案(实线代表该处有线,虚线代表背面有线),问最少需要几针才能绣出来?一针是指针不离开布的一次绣花过程。

1行两个数NM(1<=N,M<=200)。 接下来N行每行M个数描述正面。 再接下来N行每行M个数描述反面。 每个格子用.(表示空),/(表示从右上角连到左下角),\(表示从左上角连到右下角)和X(表示连两条对角线)表示。

一个数,最少要用的针数。

4 5 ..... .\... ..\.. ..... ..... ....\ .\X.. .....

4

0

 

Ural State University Problem Archive

2017-04-15 21:09:09

1

64

N

1

2

0

1512

【培训教程.回溯法】数字排列问题

列出所有从数字1到数字n的连续自然数的排列,要求所产生的任一数字序列中不允许出现重复的数字。

n(1<=n<=9)

1~n组成的所有不重复的数字序列,每行一个序列。

3

1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1

0

 

【培训教程.回溯法】

2017-04-15 21:09:09

1

64

N

0

5

0

1513

【培训教程.回溯法】邮票问题

设有已知面额的邮票m种,每种有n张。 问:用总数不超过n张的邮票进行组合,能组合的邮票面额中可以边续出现面额数最多有多少? (1<=m<=1001<=n<=1001<=邮票面额<=255

第一行:nm的值,中间用一空格隔开。 第二行:a[1..m](面额),每个数中间用一空格隔开。

max=k(其中k为连续面额数的最大值)

4 3 1 2 4

max=14

0

 

【培训教程.回溯法】

2017-04-15 21:09:09

1

64

N

0

0

0

1514

【培训教程.回溯法】n皇后问题

在一个国际棋盘上,放置n个皇后(n<=20),使她们相互之间不能进攻。求出所有布局。

n1<=n<=20

<p> 每行输出一种方案,每种方案顺序输出皇后所在的列号,各个数之间用空格隔开。 </p> <p> 若一种方案都没有找到,则输出:“no solute!” </p>

4

2 4 1 3 3 1 4 2

0

 

【培训教程.回溯法】

2018-03-08 16:41:09

1

64

N

4

18

0

1515

【培训教程.回溯法】置棋问题

m*n的主格中任意指定x个格子构成一个棋盘,在任一个构成的棋盘上放置k个棋子,要求任意两个棋子不得位于同一行或同一列上,要求输出满足条件的所有方案。 (注意棋盘是稀疏的,即x<1/2*m*n1<mn<10。) 编程要求: 1.对给定的一个棋盘,求出该棋盘可放置的最多的棋子数p 2.di为该棋盘上放置i个棋子时的方案总数(1<=i<=p),其中经旋转和镜面反射而得的方案记为不同的方案,对每一个i,求出相应的di 3.程序应能够连续处理多个棋盘,对每一个棋盘,输出pd1d2……dp,只需输出数字,不必输出具体的棋盘方案。

第一行是两个数字,代表第一个棋盘的mn,以下为一个仅由01组成的m*n矩阵,某一个位置值为1表示相应的格子在这个棋盘上,为0表示相应的格子不在棋盘上。

第一行是棋盘可放置的最多的棋子数p; 第二行分别列出放1个棋子到放p个棋子的方案总数。

<img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1515.jpg> 5 5 0 1 1 1 0 0 1 0 0 0 1 1 1 0 0 0 0 1 0 0 0 0 1 1 0

the maxnumber=4 1:10 2:28 3:24 4:5

0

 

【培训教程.回溯法】

2017-04-15 21:09:09

1

64

N

0

0

0

1516

【培训教程.回溯法】自然数的拆分问题

输入自然数n,然后将其拆分成由若干数相加的形式,参与加法运算的数可以重复。

待拆分的自然数n

若干数的加法式子。

7

7=1+6 7=1+1+5 7=1+1+1+4 7=1+1+1+1+3 7=1+1+1+1+1+2 7=1+1+1+1+1+1+1 7=1+1+1+2+2 7=1+1+2+3 7=1+2+4 7=1+2+2+2 7=1+3+3 7=2+5 7=2+2+3 7=3+4

0

 

【培训教程.回溯法】

2017-04-15 21:09:09

1

64

N

1

1

0

1517

【培训教程.回溯法】0/1字符串问题

输出仅由01组成的长度为n的字符串,并且其中不可含有三个连续的相同子串。

字符串长度nn<=40)。

所有满足条件的字符串的个数。

2

4

0

 

【培训教程.回溯法】

2017-04-15 21:09:09

10

64

N

1

1

0

1518

【培训教程.回溯法】圆盘移动问题

从左向右依次安放4根细柱ABCD。在A柱上套有nn<=20)个直径相同的圆盘,从下到上依次用连续的小写字母abc…… <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1518.jpg> 编号(如上图所示),将这些圆盘经过BC单向地移到D柱上(即不允许从右向左移动。圆盘可在BC中暂存)。要求找到从A柱初始状态到D柱目标状态的移动过程。

第一行是D柱上的圆盘总数; 第二行是D柱上由下到上的圆盘的序列。

是一个文件。该文件的每一行为一个形如“k m l”的字母序列,其中k为圆盘编号,mk盘原先的柱号,l为目标柱号。 如果不能生成排列,则输出“no solution!”

3 abc

c A B b A C a A D b C D c B D

0

 

【培训教程.回溯法】

2017-04-15 21:09:09

1

64

N

0

1

0

1519

【培训教程.回溯法】有重复元素的排列问题

问题描述: 设R{r1r2……rn}是要进行排列的n个元素。其中元素r1r2……rn可能相同。试设计一个算法,列出R的所有不同排列。 编程任务: 给定n以及待排列的n个元素。计算出这n个元素的所有不同排列。

1行是元素个数n1<=n<=15。 接下来的1行是待排列的n个元素,元素中间不要加空格。

程序运行结束时,将计算出n个元素的所有不同排列。最后1行中的数是排列总数。 (说明: 此题,所有计算出的排列原本是无所谓顺序的。但为了容易评判,输出结果必须唯一! 现做约定:所有排列的输出顺序如课本P11的例24的程序的输出顺序,区别仅是这道题含有重复元素。)

4 aacc

aacc acac acca caac caca ccaa 6

0

 

【培训教程.回溯法】

2017-04-15 21:09:09

1

64

N

0

0

0

1520

[NOIP2011]铺地毯

为了准备一个独特的颁奖典礼,组织者在会场的一片矩形区域(可看做是平面直角坐标 系的第一象限)铺上一些矩形地毯。一共有n 张地毯,编号从1 n。现在将这些地毯按照 编号从小到大的顺序平行于坐标轴先后铺设,后铺的地毯覆盖在前面已经铺好的地毯之上。 地毯铺设完成后,组织者想知道覆盖地面某个点的最上面的那张地毯的编号。注意:在矩形 地毯边界和四个顶点上的点也算被地毯覆盖。

输入共 n+2 行。 第一行,一个整数 n,表示总共有n 张地毯。 接下来的 n 行中,第i+1 行表示编号i 的地毯的信息,包含四个正整数abgk,每 两个整数之间用一个空格隔开,分别表示铺设地毯的左下角的坐标(ab)以及地毯在x 轴和y 轴方向的长度。 第 n+2 行包含两个正整数x y,表示所求的地面的点的坐标(xy)。 【输入输出样例说明1】 如下图,1 号地毯用实线表示,2 号地毯用虚线表示,3 号用双实线表示,覆盖点(2 2)的最上面一张地毯是3 号地毯。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1520.png> 【输入输出样例说明2】 如上图,1 号地毯用实线表示,2 号地毯用虚线表示,3 号用双实线表示,点(45) 没有被地毯覆盖,所以输出-1。 【数据范围】 对于 30%的数据,有n≤2; 对于 50%的数据,0≤a, b, g, k≤100; 对于 100%的数据,有0≤n≤10,0000≤a, b, g, k≤100,000

输出共 1 行,一个整数,表示所求的地毯的编号;若此处没有被地毯覆盖则输出-1

[temple 1] 3 1 0 2 3 0 2 3 3 2 1 3 3 2 2 [temple 2] 3 1 0 2 3 0 2 3 3 2 1 3 3 4 5

 

0

[temple 1] 3 [temple 2] -1

rqnoj

2017-04-15 21:09:09

1

64

N

4

5

0

1521

[NOIP 2011]聪明的质监员

 T 是一名质量监督员,最近负责检验一批矿产的质量。这批矿产共有n 个矿石,从1 n 逐一编号,每个矿石都有自己的重量wi 以及价值vi。检验矿产的流程是: 1、给定m 个区间[LiRi] 2、选出一个参数W 3、对于一个区间[LiRi],计算矿石在这个区间上的检验值Yi :这个区间上所有重量大于等于W的矿石数目与它们的价值和的乘积。 这批矿产的检验结果Y 为各个区间的检验值之和。 若这批矿产的检验结果与所给标准值S 相差太多,就需要再去检验另一批矿产。小T 不想费时间去检验另一批矿产,所以他想通过调整参数W 的值,让检验结果尽可能的靠近 标准值S,即使得S-Y 的绝对值最小。请你帮忙求出这个最小值。 【输入输出样例说明】 当 W 4 的时候,三个区间上检验值分别为2050,这批矿产的检验结果为25,此 时与标准值S 相差最小为10。 【数据范围】 对于 10%的数据,有1≤nm≤10; 对于 30%的数据,有1≤nm≤500; 对于 50%的数据,有1≤nm≤5,000; 对于 70%的数据,有1≤nm≤10,000; 对于 100%的数据,有1≤nm≤200,0000 < wi, vi≤1060 < S≤10121≤Li≤Ri≤n

第一行包含三个整数 nmS,分别表示矿石的个数、区间的个数和标准值。 接下来的 n 行,每行2 个整数,中间用空格隔开,第i+1 行表示i 号矿石的重量wi 和价 值vi 。 接下来的 m 行,表示区间,每行2 个整数,中间用空格隔开,第i+n+1 行表示区间[Li, Ri]的两个端点Li Ri。注意:不同区间可能重合或相互重叠。

输出只有一行,包含一个整数,表示所求的最小值。

5 3 15 1 5 2 5 3 5 4 5 5 5 1 5 2 4 3 3

10

0

 

rqnoj

2017-04-15 21:09:09

10

64

N

0

3

0

1522

【栈、队列】海上葬礼

有一片被大海包围的群岛,岛上居住着一个食人部族。很多年前部落里有一位巫师接受了神的召唤跳入海中,从此,那一片海域就被打上了神的烙印,被这片海域所包围的陆地也被赋予了神圣的意义(包围关系满足传递性,即海域A包围了岛B,岛B包围了海域C,而海域C中包含了岛D,则我们说海域A也包含了岛D)。从那以后,部落里的巫师死后都必须葬在这片神圣海域所包围的岛上,而且每一个岛都只能埋葬一位巫师(否则就会被视为对神的不敬,从而给部族带来灾难)。现在给你群岛的地图和最初那位巫师跳海的地方,请你计算一下最多可以埋葬多少巫师。 <img border=0 src=http://60.191.162.158:8080/JudgeOnline/images/P1522.png> 地图是一个n*m的字符矩阵,’#’代表陆地,’.’代表海洋。连通的一片陆地为一个岛,连通的一片海洋为一个海域。其中,陆地从上、下、左、右4个方向连通,海洋从上、下、左、右、左上、左下、右上、右下8个方向连通。如下图。 图3中有4个岛,2片海域。如果在A处落水,则落水的海域包围了除右上、左下两个顶角外的3个岛屿;如果在B处落水,则只包含了中间的2个岛。 数据范围是n,m<=500。空间限制1000Kb,时间限制1second

1行,包含两个整数:nmnm<=500);如: 7 9:表示有7行,9列。 第2行到n+1行;每行均为m个字符,构成一个地图,如: ........# .#######. .#.....#. .#.#.#.#. .#.....#. .#######. #........ 地图是一个n*m7*9)的字符矩阵,’#’代表陆地,’.’代表海洋。 接下来一行为一个整数k,表示下面有k行数据。如k:2;表示下面有两行: 每行均为两个整数,用来表示一个海域的位置坐标。 1 1 3 7

输出共k行,每行为一个整数,用来表示最多可以埋葬多少个巫师。 31 1坐标水域可以埋葬3个巫师) 23 7坐标水域可以埋葬3个巫师)

7 9 ........# .#######. .#.....#. .#.#.#.#. .#.....#. .#######. #........ 2 1 1 3 7

3 2

0

 

 

2017-04-15 21:09:09

1

64

N

0

0

0

1523

【栈.6】算术表达式求值

由键盘输入一个算术表达式,含有操作数和+、-、*/等运算符,运算结果为整数,编写程序,求该算术表达式的值。

输入一行,为一个算式: 4*(2+3)-10/5

输出一行,小数点保留两位有效数字: 18.00

4*(2+3)-10/5

18.00

0

 

 

2017-04-15 21:09:09

1

64

N

0

0

0

1524

【队列】细胞统计

一矩形阵列由数字09组成,数字19代表细胞,细胞的定义为沿细胞数字上下左右还是细胞数字则为同一细胞,求给定矩形阵列的细胞个数。

第一行为整数m,n(m <= 100,n <= 100分别表示m行和n) ,以下为一个mxn的矩阵

细胞的个数

4 10 0234500067 1034560500 2045600671 0000000089

4

0

 

 

2017-04-15 21:09:09

1

64

N

8

9

0

1525

【队列】表的操作

设有一个表L={a1an},其中l为表名,ai为表元素(≤i≤n)。当ai为数值时,表示为元素;当ai为大写字母时,表示另一个表,但不能循环定义。例如下列定义是合法的(约定l是第一个表的表名): L=(3434K808P) K=(558994) P=(4789) 程序要求:当全部表给出后,求出所有元素的最大元素。例如上例的最大元素为9。

输入全部表,每行一个表;

最大元素值。

L=(3434K808P) K=(558994) P=(4789)

9

0

 

 

2017-04-15 21:09:09

1

64

N

1

3

0

1526

【高精度】彩票

现今,社会上流行着各种各样的福利彩票,彩票已经融入到了人们的日常生活之中。彩票之所以能吸引那么多的人们,玩法多是一大原因。其中有一类是从前N个自然数中选出M个(不计顺序)不同的号码,如果这M个号码与摇奖时摇出的M个中奖号码完全相符,那么就中了头奖。如现在已经有的:307357367377…… 随着时间的推移,越来越多的人不满足于原来的玩法。为了追求更大的刺激,可供选择的号码和每注的号码个数越来越大,88851818888868等等应运而生。但是,由此也衍生出了许多麻烦。由于数字越来越大,福彩中心的工作人员们已经无法用一般的计数器精确地计算出每一种彩票中头奖的概率。现在请你帮助他们,编一个程序:对于每一种玩法,能够快速准确地计算出中头奖概率的倒数。

nM<=N<10^40 m0<M<=1000

“NM”的玩法中,中头奖的概率的倒数。

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

0

0

0

1527

【高精度】圣诞树

叮叮当,叮叮当,铃儿响叮当……”一年一度的圣诞节又来临了。 今年,霍比特人Timmy打算自己布置一颗圣诞树,瞧,他正往圣诞树上挂彩灯和苹果呢。Timmy的圣诞树是图一的一种形状: 这是一棵严格意义上的二叉树。然而,将其稍做变化如图二所示,就可以变成另一种形状不同的圣诞树! Timmy一下来了兴趣,他有N个彩灯或苹果要挂在圣诞树上,因此,圣诞树必须有且仅有N个节点。你能帮助Timmy统计出这样的圣诞树一共有多少种么?

N1 <= N <= 1000)。

圣诞树的种数。

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

0

0

0

1528

【贪心】删数问题

NOI94)键盘输入一个高精度的正整数n<=240位),去掉其中任意s个数字后剩下的数字按原左右次序组成一个新的正整数。 编程对给定的ns,寻找一种方案,使得剩下的数字组成的新数最小。

输入分两行,第一行为:一个高精度数N; 第二行为:所删除的数字个数S n s

输出为一秆:去掉的数字的位置后,其组成的新的正整数。 最后剩下的最小数。

178543 4

13

0

 

 

2017-04-15 21:09:09

1

64

N

3

4

0

1529

【贪心】拦截导弹

某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能高于前一发的高度。某天,雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹。 输入导弹依次飞来的高度(导弹数不超过200,雷达给出的高度数据是不大于30000的正整数), 如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

输入仅1行:每1个导弹飞行的高度。(导弹的个数不超过200 389 207 155 300 299 170 158 65

输出仅1行,即:将所有导弹拦截下来,至少需要的导弹拦截系统的数量。 2

389 207 155 300 299 170 158 65

2

0

 

 

2017-04-15 21:09:09

1

64

N

3

7

0

1530

【贪心】零件分组

  某工厂生产一批棍状零件,每个零件都有一定的长度(Li)和重量(Wi)。现在为了加工需要,要将它们分成若干组,使每一组的零件都能排成一个长度和重量都不下降(若i <= j,则Li<=LjWi<=Wj)的序列。请问至少要分成几组?

第一行为一个整数NN<=1000),表示零件的个数。 第二行有N对正整数,每对正整数表示这些零件的长度和重量,长度和重量均不超过10000

仅一行,即最少分成的组数。

5 8 4 3 8 2 3 9 7 3 5

2

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1531

【贪心】美元汇率

在以后的若干天里戴维将学习美元与德国马克的汇率。编写程序帮助戴维何时应买或卖马克或美元,使他从100美元开始,最后能获得最高可能的价值。

  输入文件的第一行是一个自然数N1≤N≤100,表示戴维学习汇率的天数。   接下来的N行中每行是一个自然数A1≤A≤1000。第i+1行的A表示预先知道的第i+1天的平均汇率,在这一天中,戴维既能用100美元买A马克也能用A马克购买100美元。

输出文件的第一行也是唯一的一行应输出要求的钱数(单位为美元,保留两位小数)。   注意:考虑到实数算术运算中进位的误差,结果在正确结果0.05美元范围内的被认为是正确的,戴维必须在最后一天结束之前将他的钱都换成美元。

5 400 300 500 300 250

266.67 样例解释 (无需输出) Day 1 ... changing 100.0000 美元= 400.0000 马克 Day 2 ... changing 400.0000 马克= 133.3333 美元 Day 3 ... changing 133.3333 美元= 666.6666 马克 Day 5 ... changing 666.6666 马克= 266.6666 美元

0

 

 

2017-04-15 21:09:09

1

64

N

0

1

0

1532

【贪心】NOIP.1998最大整数

设有n个正整数(n<=20),将它们联接成一排,组成一个最大的多位整数。 例如:n=3时,3个整数13312343联接成的最大整数为:34331213。 又如:n=4时,4个整数7134246联接成的最大整数为:7424613

n n个数

连接成的多位数。

3 13 312 343

34331213

0

 

 

2017-04-15 21:09:09

1

64

N

2

3

0

1533

【贪心】取数游戏

  给出2*n(n<=100)个自然数(数小于等于30000)。      游戏双方分别为A方(计算机方)和B方(对奕的人)。只允许从数列两头取数。   A先取,然后双方依次轮流取数。   取完时,谁取得的数字总和最大为取胜方;双方和相等,属于A胜。      请为A方设计一必胜的策略。那么在该必胜策略下A方和B方各取得的数之和为多少?

键盘输入n2*n个自然数。

2行,分别为A方取得的数和和B方取得的数和,。

4 7 9 3 6 4 2 5 3

20 19

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1534

【贪心】独木舟

我们计划组织一个独木舟旅行。租用的独木舟都是一样的,最多乘两人,而且载重有一个限度。现在要节约费用,所以要尽可能地租用最少的舟。 我们的任务是读入载重量,参加旅行的人数以及每个人的体重。计算所需要租船数目。

第一行是w, 80<=w<=200,每条船最大的载重量。 第二行是整数n, 1 <= n <= 30000,参加旅行的人数。 接下来的n行,每行是一个整数,范围[5..w]。表示每个人的重量。

一个数,即最小租用数目。

9 90 20 20 30 50 60 70 80 90

6

0

 

 

2017-04-15 21:09:09

1

64

N

0

2

0

1535

【贪心】钓鱼

在一条水平路边,有N2<=n<=25)个钓鱼湖,从左边到右编号为123、。。。、n)。佳佳有H1<=H<=16)个小时的空余时间,他希望用这些时间钓到尽量多的鱼。他从湖1出发,向右走,有选择的在一些湖边停留一定的时间钓鱼,最后在某一个湖边结束钓鱼。佳佳测出从第I个湖到I+1个湖需要走5*ti分钟的路,还测出在第I个湖边停留,第一个5分钟可以钓到鱼fi,以后再每钓5分钟鱼,鱼量减少di。为了简化问题,佳佳假定没有其他人钓鱼,也不会有其他因素影响他钓到期望数量的鱼。 请编程求出能钓最多鱼的数量。

第一行:湖的数量n。 第二行:时间h(小时)。 第三行:n个数,f1f2,。。。fn。 第四行:n个数,d1d2,。。。dn。 第五行:n-1个数,t1t2,。。。tn-1

一个数,所能钓鱼的最大数量。

2 1 10 1 2 5 2

31

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1536

【贪心】节点网络

现有一个N!个节点的网络,每个节点的编号分别是编号(A1,A2,…AN)序列的一个置换。 对于任意两个节点ST,如果T的编号是由S编号的首位与除首位外的编号中的任一位交换所得,则ST之间有一条连线,求从节点S走到节点(A1,A2,…AN)所需经过的最少边数。其中,n<=100

第一行为n; 第二行为节点s的编号。

输出:所需经过的最少边数。

4 A4A2A1A3

2

0

 

 

2017-04-15 21:09:09

1

64

N

0

2

0

1537

【贪心】d-规则问题

设定N为自然数的集合,对任意给定的mnm∈Nn∈N,满足m构造一初始集合:P={X|m≤X≤nX∈N}。设:m,n<=100. 现定义一种d规则如下:若存在a∈P,且存在K∈N,K>1,使得K*a∈P,则修改P集合为:P=P{y|y=S*a,s∈N},并称该d规则具有分值a.现要求编制一个程序,对输入的mn的值,构造相应的初始集合P,P每应用一次d规则就累加其相应的分值,求能得到最大累加分值的d规则序列,输出每次使用d规则时的分值和集合p的变化过程。

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1538

【贪心】传染病控制

背景 Background 近来,一种新的传染病肆虐全球。蓬莱国也发现了零星感染者,为防止该病在蓬莱国大范围流行,该国政府决定不惜一切代价控制传染病的蔓延。不幸的是,由于人们尚未完全认识这种传染病,难以准确判别病毒携带者,更没有研制出疫苗以保护易感人群。于是, 蓬莱国的疾病控制中心决定采取切断传播途径的方法控制疾病传播。经过 WHO(世界卫生组织)以及全球各国科研部门的努力,这种新兴传染病的传播途径和控制方法已经研究消楚,剩下的任务就是由你协助蓬莱国疾控中心制定一个有效的控制办法。 描述 Description 研究表明,这种传染病的传播具有两种很特殊的性质;   第一是它的传播途径是树型的,一个人X只可能被某个特定的人Y感染,只要Y不得病,或者是XY之间的传播途径被切断,则X就不会得病。   第二是,这种疾病的传播有周期性,在一个疾病传播周期之内,传染病将只会感染一代患者,而不会再传播给下一代。   这些性质大大减轻了蓬莱国疾病防控的压力,并且他们已经得到了国内部分易感人群的潜在传播途径图(一棵树)。但是,麻烦还没有结束。由于蓬莱国疾控中心人手不够,同时也缺乏强大的技术,以致他们在一个疾病传播周期内,只能设法切断一条传播途径,而 没有被控制的传播途径就会引起更多的易感人群被感染(也就是与当前已经被感染的人有传播途径相连,且连接途径没有被切断的人群)。当不可能有健康人被感染时,疾病就中止传播。所以,蓬莱国疾控中心要制定出一个切断传播途径的顺序,以使尽量少的人被感染。 你的程序要针对给定的树,找出合适的切断顺序。

输入格式的第一行是两个整数n1≤n≤300)和p。表示有N个人, 接下来p行,每一行有两个整数ij,表示节点ij间有边相连(意即,第i人和第j人之间有传播途径相连)。 其中节点1是已经被感染的患者。

只有一行,输出总共被感染的人数。

7 6 1 2 1 3 2 4 2 5 3 6 3 7

3

0

 

 

2017-04-15 21:09:09

1

64

N

0

0

0

1539

【树图】十字绣

背景 Background 考古学家发现了一块布,布上做有针线活,叫做十字绣,即交替地在布的两面穿线。 描述 Description 布是一个n*m的网格,线只能在网格的顶点处才能从布的一面穿到另一面。每一段线都覆盖一个单位网格的两条对角线之一,而在绣的过程中,一针中连续的两段线必须分处布的两面。给出布两面的图案,问最少需要几针才能绣出来?一针是指针不离开布的一次绣花过程。

1行两个数NM(1<=N,M<=200)。 接下来N行每行M个数描述正面。 再接下来N行每行M个数描述反面。 每个格子用.(表示空),/(表示从右上角连到左下角),\(表示从左上角连到右下角)和X(表示连两条对角线)表示。

一个数,最少要用的针数。

4 5 ..... .\... ..\.. ..... ..... ....\ .\X.. .....

4

0

 

Vijos P1015

2017-04-15 21:09:09

1

64

N

1

1

0

1540

【树图】Victoria的舞会2

  Victoria是一位颇有成就的艺术家,他因油画作品《我爱北京天安门》闻名于世界。现在,他为了报答帮助他的同行们,准备开一个舞会。   Victoria准备邀请n个已经确定的人,可是问题来了:   这n个人每一个人都有一个小花名册,名册里面写着他所愿意交流的人的名字。比如说在A的人名单里写了B,那么表示A愿意与B交流;但是B的名单里不见的有A,也就是说B不见的想与A交流。但是如果A愿意与B交流,B愿意与C交流,那么A一定愿意与C交流。也就是说交流有传递性。   Victoria觉得需要将这n个人分为m组,要求每一组的任何一人都愿意与组内其他人交流。并求出一种方案以确定m的最小值是多少。   注意:自己的名单里面不会有自己的名字。

第一行一个数n。 接下来n行,每i+1行表示编号为i的人的小花名册名单,名单以0结束。1<=n<=200

一个数,m

18 0 18 0 0 0 11 0 0 0 0 0 0 5 0 0 0 0 0 0 0 2 0

16

0

 

Vijos P1022

2017-04-15 21:09:09

1

64

N

1

1

0

1541

【树图】Victoria的舞会3

 Victoria是一位颇有成就的艺术家,他因油画作品《我爱北京天安门》闻名于世界。现在,他为了报答帮助他的同行们,准备开一个舞会。   Victoria准备邀请n个已经确定的人,可是问题来了:   这n个人每一个人都有一个小花名册,名册里面写着他能够通知到的人的名字。比如说在A的人名单里写了B,那么表示A能够通知到B;但是B的名单里不见的有A,也就是说B不见得通知到A。   Victoria觉得需要确定自己需要通知多少个人m,能够实际将所有人n都通知到。并求出一种方案以确定m的最小值是多少。   注意:自己的名单里面不会有自己的名字。Victoria可以自身通知到所有n个人。

第一行一个数n。 接下来n行,每i+1行表示编号为i的人的小花名册名单,名单以0结束。1<=n<=200

一个数,m

18 0 11 0 0 0 0 16 0 14 0 0 0 0 2 13 0 0 11 0 7 0 0 6 0 0 0

14

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1542

【树图】休息中的小呆

  当大家在考场中接受考验(折磨?)的时候,小呆正在悠闲(欠扁)地玩一个叫最初梦想的游戏。游戏描述的是一个叫pass的有志少年在不同的时空穿越对抗传说中的大魔王chinesesonic的故事。小呆发现这个游戏的故事流程设计得很复杂,它有着很多的分支剧情,但不同的分支剧情是可以同时进行的,因此游戏可以由剧情和剧情的结束点组成,某些剧情必须要在一些特定的剧情结束后才能继续发展。 为了体验游戏的完整性,小呆决定要看到所有的分支剧情——完成所有的任务。但这样做会不会耽误小呆宝贵的睡觉时间呢?所以就请你来解决这个问题了。 小呆会给你一个剧情流程和完成条件的列表, 其中第一行有一个数n0<n<100),表示总共有n个剧情结束点, 第二行一个数m(0<m<=120),表示由m个不同的剧情,下面的m行中每行有三个数i(0<i<=100),j(0<j<=100),k(0<k<=1000),表示从剧情结束点i必须完成一个耗费时间为k的剧情才能到达剧情结束点j。 注意,这m行中出现的1不是剧情结束点而是游戏的开始,而n+1表示游戏结束。 你要告诉小呆完成整个游戏至少需要多少时间以及要经过的所有可能的剧情结束点(按升序输出)。样例如下:

 

 

4 5 1 2 2 2 3 2 3 5 3 1 4 3 4 5 3

7 1 2 3 5

0

 

Vijos P1027

2017-04-15 21:09:09

1

64

N

1

1

0

1543

【树图】Kerry 的电缆网络

Kerry 是德国的一位电缆商人。因联合国脱贫计划的邀请,他准备负责在土鲁齐亚埃萨亚克斯乌托斯邦建立电缆网络,以满足这个国家的用电需求。当然,现在土鲁齐亚埃萨亚克斯乌托斯邦没有任何电缆。 已知土鲁齐亚埃萨亚克斯乌托斯邦一共有n个城镇,已经编号为1n。其中任意两个城镇可能有一条路,也可能没有。 如果两个城镇之间有一条路pi,那么这条路有一个长度si,则Kerry可以在这两个城市之间建立一条电缆线,电缆线的长度也就是这条路的长度si。   现在Kerry准备了s长的电缆线,电缆线可以任意拆断,拆断不损失任何电缆线。他需要将土鲁齐亚埃萨亚克斯乌托斯邦所有城镇都能够连入这个电缆网络。那么,Kenny能不能使用这s长度的电缆线完成这项工作;如果能够完成,那么Kerry最少耗用多少长度的电缆线呢?

第一行一个正实数S; 第二行一个正整数n; 接下来一共有m行,第i行有两个整数xi,yi和一个实数si,表示编号为xi个村庄和编号为yi个村庄之间有一条路,路的长度为si。 输入保证xi不等于yi,两个城镇之间不会有两条路。

若能够完成(建立这样的电缆网络),则输出(其中<X>代表最少的电缆线长度,保留两位小数): Need <X> miles of cable 否则输出: Impossible

100.0 4 1 2 2.0 1 3 4.2 1 4 6.7 3 4 4.0 2 4 10.0

Need 10.20 miles of cable

0

1<=n,m<=100000

Vijos P1045

2017-04-15 21:09:09

3

64

N

20

36

0

1544

【树图】送给圣诞夜的行程

背景 Background 散落的珍珠 在一所著名的古代寺院里,在它的佛堂的顶梁柱上挂着一个宝物,这个宝物垂直悬挂着,它是由许多珍珠用金线连接起来的,每根金线一端是白色的,另一端是黑色的,所有的珍珠都排成一线,且都镶在柱子里,而且每一根金线又都是绷紧的,并且金线的白色一端始终在黑色一端的上方。 有一天,也不知是年代久远加上大风还是其它的什么原因,珍珠突然从柱子里飞出,掉落下来。宝物本身是完好无损,然而僧侣们再也无法以原样把珍珠嵌入柱子里了。 现在要求你设计一个程序对于给定的数据进行周密的分析,得出这串珍珠几百年前嵌在佛堂顶梁柱上的排列模样。 给定有N个珍珠和P根金线,所有珍珠按一定顺序有了一个序号:123……N

第一行是两个正整数NP(均不大于255)。 以下P行描述珍珠连接情况: 文件第i+1行有三个整数Ri1,Ri2,Li,其中第一个整数表示第I根金线白色一端连接的珍珠序号,第二个整数表示第I根金线黑色一端连接的珍珠序号,第三个表示第i根金线的长度。

由于珍珠比较小,所以几个珍珠可以同时镶在一个位置上。 你的输出数据描述的是每颗珍珠在顶梁柱上的位置,输出文件共N行,每一行一个整数S,第I行表示第I个珍珠在顶梁柱上距离最高位置珍珠的距离。

9 9 1 2 3 2 3 5 2 7 1 4 5 4 5 6 1 5 9 1 6 7 1 7 8 3 9 8 4

2 5 10 0 4 5 6 9 5

0

第十二届全国青少年信息学奥林匹克no.1

Vijos P1050

2017-04-15 21:09:09

1

64

N

0

0

0

1545

【树图】Easy sssp

输入数据给出一个有N(2 <= N <= 1,000)个节点,M(M <= 100,000)条边的带权有向图。 要求你写一个程序, 判断这个有向图中是否存在负权回路。 如果从一个点沿着某条路径出发, 又回到了自己, 而且所经过的边上的权和小于0, 就说这条路是一个负权回路。 如果存在负权回路, 只输出一行-1; 如果不存在负权回路, 再求出一个点S(1 <= S <= N)到每个点的最短路的长度。 约定: SS的距离为0, 如果S与这个点不连通, 则输出NoPath

第一行: 点数N(2 <= N <= 1,000), 边数M(M <= 100,000), 源点S(1 <= S <= N); 以下M, 每行三个整数a, b, c表示点a, b(1 <= a, b <= N)之间连有一条边, 权值为c(-1,000,000 <= c <= 1,000,000)

如果存在负权环, 只输出一行-1, 否则按以下格式输出: 共N, i行描述S点到点i的最短路: 如果Si不连通, 输出NoPath; 如果i = S, 输出0;其他情况输出Si的最短路的长度。

6 8 1 1 3 4 1 2 6 3 4 -7 6 4 2 2 4 5 3 6 3 4 5 1 3 5 4

0 6 4 -3 -2 7

0

第十二届全国青少年信息学奥林匹克no.1 做这道题时, 你不必为超时担心, 不必为不会算法担心, 但是如此简单的题目, 你究竟能ac?

Vijos P1053

2017-04-15 21:09:09

1

64

N

0

0

0

1546

【树图】新年趣事之游戏

  xiaomengxian的哥哥是一个游戏迷,他喜欢研究各种游戏。 这天,xiaomengxian到他家玩,他便拿出了自己最近正在研究的一个游戏给xiaomengxian看。这个游戏是这样的: 一个国家有N个城市,有些城市之间可以建设铁路,并且不同城市之间建设铁路的费用各不相同。问如何用最小的费用,使整个国家的各个城市之间能够互相到达。 另外,铁路是双向的。xiaomengxian心想,这不是太简单了吗?这就是经典的MST问题。他的哥哥说,这个当然不算什么。关键是它还要求费用第二小的方案,这真是让人伤脑筋。xiaomengxian想了很久,也没有想出来,你能帮助他吗?   费用第二小的方案的定义为:与费用最小的方案不完全相同,且费用值除费用最小的方案外最小。

第一行两个数N2<=N<=500),M,分别表示国家的城市数和可以修建铁路的城市有多少对。 接下来M行,每行三个正整数AiBiCi,表示城市AiBi之间可以修建铁路,费用为Ci

第一行:”Cost: “+一个整数,表示最小费用。(若不存在,输出-1) 第二行:”Cost: “+一个整数,表示第二小费用。(若不存在,输出-1

4 6 1 2 2 2 3 2 3 4 2 4 1 2 1 3 1 2 4 1

Cost: 4 Cost: 4

0

注释 Hint Sample input #2 3 2 1 2 2 2 3 2 Sample output #2 Cost: 4 Cost: -1

Vijos P1070

2017-04-15 21:09:09

1

64

N

0

0

0

1547

【贪心】Victoria的舞会1

  Victoria是一位颇有成就的艺术家,他因油画作品《我爱北京天安门》闻名于世界。现在,他为了报答帮助他的同行们,准备开一个舞会。   Victoria准备邀请n个已经确定的人,可是问题来了:   这n个人每一个人都有一个小花名册,名册里面写着他所愿意交流的人的名字。比如说在A的人名单里写了B,那么表示A愿意与B交流;而且如果A名单里面有B,那么B名单里面肯定有A,也就是说两个人如果一方愿意和另一方交流,那么另一方也肯定愿意和这一方交流。   Victoria觉得需要在这n个人里面确定m个人,保证这m个人每一个人都能在舞会中找到至少k个人交流,并求出一种方案以确定m的最大值是多少。   注意:自己的名单里面不会有自己的名字。

第一行两个数nk。接下来n行,每i+1行表示编号为i的人的小花名册名单,名单以0结束。1<=n,k<=200

一个数,m

22 1 4 5 10 11 20 21 0 2 3 6 8 11 16 0 2 3 5 8 12 15 16 18 0 1 5 6 10 11 12 16 18 0 1 3 4 16 20 0 2 4 19 21 22 0 8 9 13 19 20 0 2 3 7 10 19 0 7 10 14 16 19 0 1 4 8 9 10 20 0 1 2 4 18 19 20 21 0 3 4 13 0 7 12 15 16 18 19 21 22 0 9 16 0 3 13 21 0 2 3 4 5 9 13 14 20 0 18 22 0 3 4 11 13 17 21 0 6 7 8 9 11 13 19 21 22 0 1 5 7 10 11 16 21 22 0 1 6 11 13 15 18 19 20 0 6 13 17 19 20 0

22

0

 

Vijos P1021

2017-04-15 21:09:09

1

64

N

2

2

0

1548

【贪心】最小差距

  给定一些不同的一位数字,你可以从这些数字中选择若干个,并将它们按一定顺序排列,组成一个整数,把剩下的数字按一定顺序排列,组成另一个整数。组成的整数不能以0开头(除非这个整数只有1位)。   例如,给定6个数字,0,1,2,4,6,7,你可以用它们组成一对数102467,当然,还可以组成其他的很多对数,比如210764204176。这些对数中两个数差的绝对值最小的是204176,为28。   给定N个不同的0~9之间的数字,请你求出用这些数字组成的每对数中,差的绝对值最小的一对(或多对)数的绝对值是多少?

第一行包括一个数TT≤1000),为测试数据的组数。 每组数据包括两行: 第一行为一个数N2≤N≤10),表示数字的个数。 下面一行为N个不同的一位数字。

T行,每行一个数,表示第i个数据的答案。即最小的差的绝对值。

2 6 0 1 2 4 6 7 4 1 6 3 4

28 5

0

 

Vijos P1039

2017-04-15 21:09:09

1

64

N

0

0

0

1549

【树图】旅游路线

Bytelandn个城市(编号从1n),它们之间通过双向的道路相连。Byteland的国王并不大方,所以,那里只有 n–1 条道路,但是,它们的连接方式使得从任意城市都可以走到其他的任何城市。 一天,starhder到了编号为k的城市。他计划从城市k开始,游遍城市m1m2m3……mj(不一定要按这个顺序旅游)。每个城市mi都是不同的,并且,也与k不同。 Starhder —— 就像每一个旅行家一样,携带的钱总是有限的,所以,他要以最短的路程旅行完所有的城市(从城市k开始)。 于是,他请你帮助计算一下,旅游完上述的城市最短需要多少路程。

第一行包含两个整数,上文中的nk,以一个空格隔开。(2<= n <=500001 <= k <=n) 下面的 n–1 行每行描述一条路,第i + 1行包含3个整数aibidi,相邻两个数用一个空格隔开(1<= ai,bi <= n1<= di <= 1000),aibi是用道路直接相连的城市编号,di是这条道路的长度。 第n + 1行包含一个整数j,是starhder要旅游的城市数(1<= j <= n - 1),接下来一行包含j个不同的整数m1m2……mj,每两个相邻的整数用一个空格隔开,表示starhder想要去的城市。(1<= mt<=nmt <> k)。

输出只有一行,包含一个整数:starhder旅游的最短路程。

4 2 1 2 1 4 2 2 2 3 3 2 1 3

5

0

 

 

2017-04-15 21:09:09

1

64

N

0

0

0

1550

【树图】starhder的旅游

starhder突发奇想,要去G地,于是他搞来了一张地图,看怎么走才好。 地图上有很多城市,G地也是一座城市。每两座城市之间都可能有直达方法,也有可能两座城市之间并不能直接相通,而要通过其他的城市转达。对于两个城市之间的直达方法,需要一定的时间,当然,如果从A城市到B城市的直达方法需要T时间,那么从B城市到A城市的直达方法也是T时间。 starhder想要用最短的时间到达G地,但是有个问题,他发现,地图上有些城市对他很有吸引力。所以他要在经过这些城市的基础上时间最短。 starhder已经用12345……n标记了他可能经过的城市(1代表出发地,n代表G地),但是眼花缭乱的地图让他感到烦恼。他请你来解决这个问题,告诉他最小需要多少时间到达G地。

输入文件的第一行是三个正整数nmt n表示总共有多少个城市(包括出发地和G地),城市数不会超过200个; m是城市的直达路线数(1<=m<=20000); t表示一定去的城市数0<=t<=10(不包括出发地和G地)。 接下来一行有t个整数,表示一定要去的城市。 接下来m行,每行包含三个正整数, 前两个数表示分别代表一个城市; 第三个数是这两个城市之间的直达时间。直达时间不会超过1000000

输出一个数,题目要求的得最短时间。

5 10 2 2 3 1 2 5 1 3 45 1 4 61 1 5 81 2 3 9 2 4 91 2 5 4 3 4 74 3 5 42 4 5 61

27

0

 

 

2017-04-15 21:09:09

5

64

N

1

1

0

1551

【树图】单词游戏

IoAo在玩一个单词游戏。他们轮流说出一个仅包含元音字母的单词,并且后一个单词的第一个字母必须与前一个单词的最后一个字母一致。游戏可以从任何一个单词开始。   任何单词禁止说两遍,游戏中只能使用给定词典中含有的单词。   游戏的复杂度定义为游戏中所使用的单词的长度总和。   编写程序求出使用一本给定的词典来玩这个游戏所能达到的游戏最大可能复杂度。

输入文件的第一行包含一个自然数N1≤N≤16N表示一本字典中包含的单词数量。 以下的每一行包含字典中的一个单词,每一个单词是由字母AEIOU组成的一个字符串,每个单词的长度将小于等于100,所有的单词是不一样的。

输出文件仅有一行包含该游戏的最大可能复杂度。

5 IOO IUUO AI OIOOI AOOI

16

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1552

【树图】删边问题

连通图是指任意两个顶点都有路径可互相到达的图。 读入一个无向的连通图,输出最多能删掉多少条边,使这个图仍然连通。

第一行为图的顶点数N1<=N<=100)和边数M,它们之间用一个空格隔开,图中的顶点用1N的整数标号。 接下来的M行,每行用两个数v1v2表示一条边。v1v2用一个空格隔开,表示这条边所连接的顶点的标号(v1<>v2),同一条边不会重复出现。

输出最多能删掉的边数。

5 7 4 6 1 2 1 3 1 4 2 3 2 4 3 4

3

0

 

 

2017-04-15 21:09:09

1

64

N

16

19

0

1553

【树图】烦人的幻灯片问题

李教授将于今天下午作一次非常重要的演讲。不幸的事他不是一个非常爱整洁的人,他把自己演讲要用的幻灯片随便堆在了一起。因此,演讲之前他不得不去整理这些幻灯片。作为一个讲求效率的学者,他希望尽可能简单地完成它。 教授这次演讲一共要用n张幻灯片(n<=26),这n张幻灯片按照演讲要使用的顺序已经用数字1~n编了号。因为幻灯片是透明的,所以我们不能一下子看清每一个数字所对应的幻灯片。 现在我们用大写字母A,B,C……再次把幻灯片依次编号。你的任务是编写一个程序,把幻灯片的数字编号和字母编号对应起来,显然这种对应应该是唯一的;若出现多种对应的情况或是某些数字编号和字母编号对应不起来,我们称对应是无法实现的。

文件的第一行只有一个整数n,表示有n张幻灯片; 接下来的n行每行包括4个整数xmin,xmax,ymin,ymax(整数之间用空格分开)为幻灯片的坐标; 这n张幻灯片按其在文件中出现的顺序从前到后依次编号为A,B,C……,再接下来的n行依次为n个数字编号的坐标x,y,显然在幻灯片之外是不会有数字的。

若是对应可以实现,输出文件应该包括n行,每一行为一个字母和一个数字,中间以一个空格隔开,并且每行以字母的生序排列; 注意输出的字母要大写并且定格;反之,若是对应无法实现,在文件的第一行顶格输出None即可。首行末无多余的空格。

4 6 22 10 20 4 18 6 16 8 20 2 18 10 24 4 8 9 15 19 17 11 7 21 11

A 4 B 1 C 2 D 3

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1554

【树图】字母排序问题

G教授是xoi的负责人,有一天他竟然发现自己的计算机染上了一种不常见的病毒。这种病毒的名字叫做ALPHABETVIRUS,当它发作时,会将字母用其它的字母代替,但不会将淡菜的顺序交换。 病毒将计算机中的所有文档都作了相对应的改变。很幸运,G教授的计算机上有一个字典,而我们都知道字典单词是按字母顺序排列的,当然,这个字典也被病毒改变了。因此,利用字典原来的有序性,找到自动替换字母的规律,再用以恢复其它文档。由于XOI不能缺少G教授的文件,所以文档必须恢复。但是由于G教授有其它更重要的工作要完成,所以他希望你可以帮助他恢复文档,使得XOI的工作可以继续。 G教授会提供感染病毒后的字典和他希望能帮助恢复的字典足。

输入文件的第一行是两个整数AA<=26)K(K<=50000), A表示需要恢复的字母的个数; K表示字典里与这几个字母有关系的单词个数,它们之间用一个空格隔开。 接下来的K行按原来的字典顺序给出这K个单词。第K+1行是要你恢复的字母组,字母为小写字母。

输出文件应该将字母组输出,如果不可将字母区分,则输出0

5 6 cebdbac cac ecd dca aba bac cedab

abcde

0

 

 

2017-04-15 21:09:09

1

64

N

2

2

0

1555

【树图】投递问题

有一座10层高的建筑物,搬运工小李需要搬运一些包裹来往于各楼层之间。小李可以不搬运任何包裹而上楼下楼,也可以在搬运某一包裹的途中停下来,将该包裹放在他所处的楼层,然后去做其它事情。 小李从一层开始工作,并且工作结束后他必须返回一层。 现在请你编写一个程序,求出小李完成工作徐需的最少上楼层数m(下楼层数不计),并且输出其搬运路径。

文件的第一行有一个正整数k0<k<=50),表示搬运工所需搬运的包裹数。 接下来有k行,每行有两个整数(整数之间用一个空格隔开)。 第s(2<=s<=k+1)行的两个整数ij; 即(1<=i,j<=10),表示s-1号包裹需要从第i层搬运到第j层。

文件的第一行是一个整数m,表示搬运工完成工作所需得最少上楼层数。

7 1 10 3 2 4 3 6 7 8 9 3 4 4 3

12

0

 

 

2017-04-15 21:09:09

1

64

N

0

0

0

1556

【树图】银河贸易问题

随着一种称为的超时空宇宙飞船的发明,一种叫做¥¥的地球与遥远的银河之间的商品进出口活动应运而生。¥¥希望从PluralZ星团中的一些银河进口商品,这些银河中的行星盛产昂贵的商品和原材料。初步的报告显示: (1) 每个银河都包含至少一个和最多26个行星,在一个银河的每个行星用A~Z中的一个字母给以唯一的标识。 (2) 每个行星都专门生产和出口一种商品,在同一银河的不同行星出口不同的商品。 (3) 一些行星之间有超时空货运航线连接。如果行星AB相连,则它们可以自由贸易;如果行星CB相连而不与A相连,则AC之间仍可通过B进行贸易,不过B要扣留5%的货物作为通行费。一般来说,只要两个行星之间可以通过一组货运航线连接,他们就可以进行贸易,不过每个中转站都要扣留5%的货物作为通行费。 (4) 在每个银河至少有一个行星开放一条通往地球的¥航线。对商业来说,¥航线和其他星际航线一样。 ¥¥已经对每个行星的主要出口商品定价(不超过10的正实数),数值越高,商品的价值越高。在本地市场,越值钱的商品获利也越高。问题是要确定如果要考虑通行费是,哪个行星的商品价值最高。

输入包含若干银河的描述。 每个银河的描述开始的第1行是一个整数n,表示银河的行星数。 接下来的n行每行包括一个行星的描述,即: (1)一行用以代表行星的字母; (2)一个空格; (3)以d.dd的形式给出该行星的出口商品的价值; (4)一个空格; (5)一个包含字母和(或)字符“*”的字符串;字母表示一条通往该行星的货运航线;“*”表示该行星向地球开放¥货运航线。

对每个银河的描述,输出一个字母P表示在考虑通行费的前提下,行星P具有最高价值的出口商品。 如果用有最高价值的出口商品的行星多于一个,只需输出字母序最小的那个行星。

5 E 0.01 *A D 0.01 A* C 0.01 *A A 1.00 EDCB B 0.01 A*

A

0

 

 

2017-04-15 21:09:09

1

64

N

0

0

0

1557

【树图】单行道问题

在某个城市有n个著名的风景点,风景点之间通过一些单行道和双行道进行连接。游客无论从哪个风景点出发,都可以沿着这些道路到达其他任何一个风景点。但是随着游客越来越多,交通事故也逐渐增加。因为单行道显然比双行道要安全得多,所以市长决定把尽可能多的双行道改成单行道,以减少事故的发生。刚好今年的JSOI比赛就在该市举行,而你是参赛选手之一,于是市长决定把这个任务交给你来完成。 现在你的任务就是调整这个城市的交通系统,把尽可能多的双行道改造成单行道,并确定它们的方向。要注意的是你不能改变原有单行道的方向,也不能另外新建一些道路,还必须保证经过改造的交通系统仍然能够让游客在任何两个风景点之间往返。

输入第一行是两个数n,m, (2<=n<=200n-1<=m<=n(n-1)/2;其中n是风景点的数目,m是所有当行道和双行道的总数目。) 以下m行每行有3个数a,b,c。(1<=a<=n1<=b<=na<>bc=1或者2。) 如果c=1,则表示有一条从ab的单行道; 如果c=2,则表示ab之间有一条双行道。 任意两个风景点之间至多有一条道路。

需要改造的双行道的数目。

4 4 4 1 1 4 2 2 1 2 1 1 3 2

1

0

 

 

2017-04-15 21:09:09

1

64

N

0

0

0

1558

【树图】拦截匪徒问题

某市的地图是一个由n个点组成的无向图,每个点代表一个区。现在第p区发生了抢劫案,而警察为了借助劫匪需埋伏在一个劫匪必经的区域。 由于不知道劫匪会向哪个区域逃窜,所以市长要求你计算出对于任意一个劫匪可能逃向的区j,找出一个可以截住劫匪的区kk<>p,k<>j),即劫匪从p区逃向j区,必经过k区。 由于地区j可能为匪徒的老巢所在,所以警察希望能在路上拦住匪徒,而不是在j区抓捕。

第一行为n,p1<=p<=n<=100) 接下来为n*n的矩阵AA[ij]=1表示i区与j区有路相连,A[ij]=0则反之。

输出n-1行,按顺序从j=1,2,……p-1,p+1,……,n依次输出对于每一个警察可以在哪些点埋伏。 如有多个点,要按从小到大顺序依次输出;如没有,则对应行输出“No”

7 1 0 0 0 0 1 0 0 0 0 0 1 0 1 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 1 0 0 1 1 0 1 0 0 0 1 0 0 0 0 0

5 5 6 5 No 5 2 5

0

 

 

2017-04-15 21:09:09

1

64

N

0

0

0

1559

2012浙江省选】数列(sequence)

小白和小蓝在一起上数学课,下课后老师留了一道作业,求下面这个数列的通项公式: <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1559.jpg > 小白作为一个数学爱好者,很快就计算出了这个数列的通项公式。于是,小白告诉小蓝自己已经做出来了,但为了防止小蓝抄作业,小白并不想把公式公布出来。于是小白为了向小蓝证明自己的确做出来了此题以达到其炫耀的目的,想出了一个绝妙的方法:即让小蓝说一个正整数N,小白则说出 的值,如果当N很大时小白仍能很快的说出正确答案,这就说明小白的确得到了公式。但这个方法有一个很大的漏洞:小蓝自己不会做,没法验证小白的答案是否正确。作为小蓝的好友,你能帮帮小蓝吗?

输入文件第一行有且只有一个正整数T,表示测试数据的组数。 第2T+1行,每行一个非负整数N

输出文件共包含T行。 第i行应包含一个不含多余前缀0的数,它的值应等于An (n为输入数据中第i+1行被读入的整数)

3 1 3 10

1 2 3

0

【数据范围】 对于20%的数据, N<=10^8 对于50%的数据, N<=10^13 对于100%的数据,T<=20 , N<=10^100

 

2017-04-15 21:09:09

1

64

N

2

2

0

1560

2012浙江省选】旅游(journey)

到了难得的暑假,为了庆祝小白在数学考试中取得的优异成绩,小蓝决定带小白出去旅游~~ 经过一番抉择,两人决定将T国作为他们的目的地。T国的国土可以用一个凸N边形来表示,N个顶点表示N个入境/出境口。T国包含N-2个城市,每个城市都是顶点均为N边形顶点的三角形(换而言之,城市组成了关于T国的一个三角剖分)。两人的旅游路线可以看做是连接N个顶点中不相邻两点的线段。 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1560.jpg > 为了能够买到最好的纪念品,小白希望旅游路线上经过的城市尽量多。作为小蓝的好友,你能帮帮小蓝吗?

每个输入文件中仅包含一个测试数据。 第一行包含两个由空格隔开的正整数NN的含义如题目所述。 接下来有N-2行,每行包含三个整数 p,q,r,表示该城市三角形的三个顶点的编号(T国的N个顶点按顺时间方向从1n编号)

输出文件共包含1行,表示最多经过的城市数目。(一个城市被当做经过当且仅当其与线路有至少两个公共点)

6 1 2 4 2 3 4 1 4 5 1 5 6

4

0

对于20%的数据, N<=2000 对于100%的数据, 4<=N<=200000

 

2017-04-15 21:09:09

1

64

N

0

0

0

1561

2012浙江省选】小蓝的好友(mrx)

终于到达了这次选拔赛的最后一题,想必你已经厌倦了小蓝和小白的故事,为了回馈各位比赛选手,此题的主角是贯穿这次比赛的关键人物——小蓝的好友。 在帮小蓝确定了旅游路线后,小蓝的好友也不会浪费这个难得的暑假。与小蓝不同,小蓝的好友并不想将时间花在旅游上,而是盯上了最近发行的即时战略游戏——SangoCraft。但在前往通关之路的道路上,一个小游戏挡住了小蓝的好友的步伐。 国家的战争其本质是抢夺资源的战争是整款游戏的核心理念,这个小游戏也不例外。简单来说,用户需要在给定的长方形土地上选出一块子矩形,而系统随机生成了N个资源点,位于用户所选的长方形土地上的资源点越多,给予用户的奖励也越多。悲剧的是,小 蓝的好友虽然拥有着极其优秀的能力,但同时也有着极差的RP,小蓝的好友所选的区域总是没有一个资源点。 终于有一天,小蓝的好友决定投诉这款游戏的制造厂商,为了搜集证据,小蓝的好友想算出至少包含一个资源点的区域的数量。作为小蓝的好友,这自然是你分内之事。

每个输入文件中仅包含一个测试数据。 第一行包含两个由空格隔开的正整数R,C,N,表示游戏在一块[1,R]X[1,C]的地图上生成了N个资源点。 接下来有N行,每行包含两个整数 x,y,表示这个资源点的坐标(1<=x<=R1<=y<=C )

输出文件应仅包含一个整数,表示至少包含一个资源点的区域的数量。具体的说,设N个资源点的坐标为XiYi (i=1..n),你需要计算有多少个四元组(LB,DB,RB,UB)满足 1<=LB<=RB<=R 1<=DB<=UB<=C 且存在一个i使得 LB<=Xi<=RBDB<=Yi<=UB 均成立。

5 5 4 1 2 2 3 3 5 4 1

139

0

对于20%的数据, N<=50 对于40%的数据, N<=2000 对于100%的数据,R,C<=40000 N<=100000 资源点的位置两两不同,且位置为随机生成。

 

2017-04-15 21:09:09

1

64

N

0

0

0

1562

【树图】有向图的存储:邻接表表示法

<img border="0" src="http://127.0.0.1:80/JudgeOnline/images/P1561_1.jpg" /> <img border="0" src="http://127.0.0.1:80/JudgeOnline/images/P1561_2.jpg" /> 以图(C)为样栵;读入。

读入第一行,图中结点的数量n,以及图中边的数量m,其中(2<=nm<=1000) 接下来共m行,每行为a,b,w ab为边的两个端点;w为该边的权值)

输出第一行:该图中结点出度最大的结点编号。 接下来多行,每行两个整数:mw (与该结点相关联的边的结点编号:m 以及权值:w

5 8 1 2 5 1 3 8 1 5 3 2 3 2 2 5 6 3 4 10 3 5 4 3 2 11

1 5 3 3 8 2 5 3 2 11 5 4 4 10

0

如果该图有多个结点出度均最大,则输出所有数据,每一组数据间间隔一行。

 

2018-04-03 09:14:38

1

64

N

2

2

0

1563

【树图】深度优先遍历(DFSP67

<img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1561_1.jpg > <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1561_2.jpg > 以图(C)为样栵;读入。 同时输出从某个结点出发的深度优先遍历(DFS)

读入第一行,图中结点的数量n,以及图中边的数量m,其中(2<=nm<=1000) 接下来共m行,每行为a,b,w ab为边的两个端点;w为该边的权值) 最后一行,读入图中一个结点编号。

输出从该结点出发的深度优先遍历(DFS) 输出一行,每一个结点编号间用空格间隔开。

5 8 1 2 5 1 3 8 1 5 3 2 3 2 2 5 6 3 4 10 3 5 4 4 5 11 3

3 1 2 5 4

0

 

 

2017-04-15 21:09:09

1

64

N

1

2

0

1564

【树图】广度优先遍历(BFSP68

<img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1561_1.jpg > <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1561_2.jpg > 以图(C)为样栵;读入。 同时输出从某个结点出发的广度优先遍历(BFS)

读入第一行,图中结点的数量n,以及图中边的数量m,其中(2<=nm<=1000) 接下来共m行,每行为a,b,w ab为边的两个端点;w为该边的权值) 最后一行,读入图中一个结点编号。

输出从该结点出发的广度优先遍历(DFS) 输出一行,每一个结点编号间用空格间隔开。

5 8 1 2 5 1 3 8 1 5 3 2 3 2 2 5 6 3 4 10 3 5 4 4 5 11 3

3 1 2 4 5

0

 

 

2017-04-15 21:09:09

1

64

N

1

2

0

1565

【树图】最小生成树:Prim算法

读入一个带权连通图。(1、连通的无向图;2、强连通的有向图) <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1565_1.jpg > 基本思想: 1. 在图G=(V, E) V表示顶点 ,E表示边)中,从集合V中任取一个顶点(例如取顶点v0)放入集合 U中,这时 U={v0},集合T(E)为空。 2. 寻找最小权值边,其中一个顶点在U中,(与U中顶点相邻的另一顶点在V中)权值最小的边的另一顶点v1,并使v1加入U。即U={v0,v1},同时将该边加入集合T(E)中。 3. 重复2,直到U=V为止。 这时T(E)中有n-1条边,T = (U, T(E))就是一棵最小生成树。 Prim:最小生成树: 任取一个顶点加入生成树,然后对那些一个端点在生成树中,而另一个端点不在生成树中的边进行排序,取权值最小的边,将它和另一个端点加进生成树中。 重复上述步骤直到所有顶点都进入了生成树为止。

第一直读入两个整数,结点数n;边数m; 接下来读入m行,每行均为3个整数:(ab),w表示无向图;或 <ab>w表示有向图

依次输出各个结点在无向图的连接情况。

6 10 ( 1, 2) 7 ( 1, 3) 6 ( 1, 4) 2 ( 2, 4) 4 ( 2, 5) 4 ( 3, 4) 5 ( 3, 6) 3 ( 4, 5) 5 ( 4, 6) 4 ( 5, 6) 6 ****##########****** (说明:以上是数据读入整人模式,涉及字符串处理,建议掌握好;常见数据读入模式有,如下:) 6 0 7 6 2 0 0 7 0 0 4 4 0 6 0 0 5 0 3 2 4 5 0 5 4 0 4 0 5 0 6 0 0 3 4 6 0

1--->1 2--->4 3--->6 4--->1 5--->2 6--->4 ****##########****** (说明:以上是数据读出整人模式,建议掌握好;常见数据读入模式有:输出最小生成树对应的总费用,如下:) 17

0

Prim算法的堆优化朴素的Prim算法如果使用邻接矩阵来保存图的话,时间复杂度是O(N^2),观察代码很容易发现,时间主要浪费在每次都要遍历所有点找一个最小距离的顶点,对于这个操作,我们很容易想到用堆来优化,使得每次可以在log级别的时间找到距离最小的点。下面的代码是一个使用二叉堆实现的堆优化Prim算法,代码使用邻接表来保存图。另外,需要说明的是,为了松弛操作的方便, 堆里面保存的顶点的标号,而不是到顶点的距离,所以我们还需要维护一个映射pos[x]表示顶点x在堆里面的位置。 使用二叉堆优化Prim算法的时间复杂度为O((V + E) log(V)) = O(E log(V)),对于稀疏图相对于朴素算法的优化是巨大的,然而100行左右的二叉堆优化Prim相对于40行左右的并查集优化Kruskal,无论是在效率上,还是编程复杂度上并不具备多大的优势。另外,我们还可以用更高级的堆来进一步优化时间界,比如使用斐波那契堆优化后的时间界为O(E + V log(V)),但编程复杂度也会变得更高。 --YangZX 22:17 2011911 (CST) /* 二叉堆优化Prim算法 Author:YangZX Date9.11 2011 */ #include <iostream> using namespace std; const int MAXV = 10001, MAXE = 100001, INF = (~0u)>>2; struct edge{ int t, w, next; }es[MAXE * 2]; int h[MAXV], cnt, n, m, heap[MAXV], size, pos[MAXV], dist[MAXV]; void addedge(int x, int y, int z) { es[++cnt].t = y; es[cnt].next = h[x]; es[cnt].w = z; h[x] = cnt; } void heapup(int k) { while(k > 1){ if(dist[heap[k>>1]] > dist[heap[k]]){ swap(pos[heap[k>>1]], pos[heap[k]]); swap(heap[k>>1], heap[k]); k>>=1; }else break; } } void heapdown(int k) { while((k<<1) <= size){ int j; if((k<<1) == size || dist[heap[(k<<1)]] < dist[heap[(k<<1)+1]]) j = (k<<1); else j = (k<<1) + 1; if(dist[heap[k]] > dist[heap[j]]){ swap(pos[heap[k]], pos[heap[j]]); swap(heap[k], heap[j]); k=j; }else break; } } void push(int v, int d) { dist[v] = d; heap[++size] = v; pos[v] = size; heapup(size); } int pop() { int ret = heap[1]; swap(pos[heap[size]], pos[heap[1]]); swap(heap[size], heap[1]); size--; heapdown(1); return ret; } int prim() { int mst = 0, i, p; push(1, 0); for(i=2; i<=n; i++) push(i, INF); for(i=1; i<=n; i++){ int t = pop(); mst += dist[t]; pos[t] = -1; for(p = h[t]; p; p = es[p].next){ int dst = es[p].t; if(pos[dst] != -1 && dist[dst] > es[p].w){ dist[dst] = es[p].w; heapup(pos[dst]); heapdown(pos[dst]); } } } return mst; } int main() { cin>>n>>m; for(int i=1; i<=m; i++){ int x, y, z; cin>>x>>y>>z; addedge(x, y, z); addedge(y, x, z); } cout<<prim()<<endl; return 0; }

 

2017-04-15 21:09:09

1

64

N

0

1

0

1566

【树图】最小生成树:Kruskal算法

基本思想: 假设WN=(V,{E})是一个含有n个顶点的连通网,则按照克鲁斯卡尔算法构造最小生成树的过程为: (1)先构造一个只含n个顶点,而边集为空的子图,若将该子图中各个顶点看成是各棵树上的根结点,则它是一个含有n棵树的一个森林。 (2)之后,从网的边集E中选取一条权值最小的边,若该条边的两个顶点分属不同的树,则将其加入子图,也就是说,将这两个顶点分别所在的两棵树合成一棵树;反之,若该条边的两个顶点已落在同一棵树上,则不可取,而应该取下一条权值最小的边再试之。 依次类推,直至森林中只有一棵树,也即子图中含有n-1条边为止。 读入一个带权连通图。(1、连通的无向图;2、强连通的有向图) <img border="0" src="http://127.0.0.1:80/JudgeOnline/images/P1565_1.jpg" /> Procedure kruskal(V,E); begin sort(E,1,m);//将边按照权值排序 for t:=1 to m do begin if getfather(edge[t].u)<>getfather(edge[t].v) then begin //利用并查集判断两个顶点是否在同一集合内 tot:=tot+edge[t].data;//计算权值和 union(edge[t].u,edge[t].v);//合并顶点 inc(k);//合并次数 end; end; if k=n-1 then 形成了一棵最小生成树 else 不存在这样的最小生成树; end;

第一直读入两个整数,结点数n;边数m; 接下来读入m行,每行均为3个整数:(ab),w表示无向图;或 <ab>w表示有向图</ab>

<p> 输出为一个整数:17 </p> <p> 若无法连通,则输出:no </p> <p> 不需要输出各个结点在无向图的连接情况。 </p>

6 10 (1,2) 7 (1,3) 6 (1,4) 2 (2,4) 4 (2,5) 4 (3,4) 5 (3,6) 3 (4,5) 5 (4,6) 4 (5,6) 6

17 {(不需要输出)例如: 1-->4 3-->6 2-->4 2-->5 4-->6}

0

<br />

 

2018-04-04 14:20:14

1

64

N

3

3

0

2060

【二维并查集】格子游戏

<p style="vertical-align:baseline;"> AliceBob玩了一个古老的游戏:首先画一个n * n的点阵(下图n = 3  接着,他们两个轮流在相邻的点之间画上红边和蓝边: </p> <p style="vertical-align:baseline;"> <img src="/JudgeOnline/upload/image/20180408/20180408003717_29415.jpg" alt="" /> </p> <p style="vertical-align:baseline;"> <p style="vertical-align:baseline;"> 直到围成一个封闭的圈(面积不必为1)为止,封圈的那个人就是赢家。因为棋盘实在是太大了(n <= 200),他们的游戏实在是太长了!他们甚至在游戏中都不知道谁赢得了游戏。于是请你写一个程序,帮助他们计算他们是否结束了游戏?  </p> </p>

输入数据第一行为两个整数nmm表示一共画了m条线。以后m行,每行首先有两个数字(x, y),代表了画线的起点坐标,接着用空格隔开一个字符,假如字符是"D ",则是向下连一条边,如果是"R "就是向右连一条边。输入数据不会有重复的边且保证正确。 

输出一行:在第几步的时候结束。假如m步之后也没有结束,则输出一行“draw”

3 5   1 1 D   1 1 R   1 2 D   2 1 R   2 2 D

4

0

 

 

2018-04-08 00:38:06

1

128

N

7

11

0

1567

【树图】单源点最短路(堆版本)

<img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1561_1.jpg > <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1561_2.jpg > 以图(C)为样栵;读入。

读入第一行,图中结点的数量n,以及图中边的数量m,其中(2<=nm<=1000) 接下来共m行,每行为a,b,w ab为边的两个端点;w为该边的权值)

依次计算出从源点1到其他各个顶点的最短路径长度; 输出所有的单源点路径长度和,一个整数表示。

5 8 1 2 5 1 3 8 1 5 3 2 3 2 2 5 6 3 4 10 3 5 4 4 5 11

29

0

 

 

2017-04-15 21:09:09

1

64

N

5

5

0

1568

【排序】堆排序算法

堆排序原理及分析: 起源   1991年计算机先驱奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德(Robert WFloyd)和威廉姆斯(JWilliams)在1964年共同发明了著名的堆排序算法( Heap Sort ) 定义:   n个关键字序列KlK2Kn称为(Heap),当且仅当该序列满足如下性质(简称为堆性质):    (1)ki <= k(2i)且 ki <= k(2i+1)(1≤i≤ n),当然,这是小根堆,大根堆则换成>=号。 //k(i)相当于二叉树的非叶结点,K(2i)则是左孩子,k(2i+1)是右孩子    若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构,则堆实质上是满足如下性质的完全二叉树:    树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。    【例】关键字序列(101556253070)和(705630251510)分别满足堆性质(1)和(2),故它们均是堆,其对应的完全二叉树分别如小根堆示例和大根堆示例所示。 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1568_1.jpg > 大根堆和小根堆: 根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小根堆,又称最小堆。 根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者,称为大根堆,又称最大堆。 注意:堆中任一子树亦是堆。以上讨论的堆实际上是二叉堆(Binary Heap),类似地可定义k叉堆。 堆的高度:   堆可以被看成是一棵树,结点在堆中的高度可以被定义为从本结点到叶子结点的最长简单下降路径上边的数目; 定义堆的高度为树根的高度。 我们将看到,堆结构上的一些基本操作的运行时间至多是与树的高度成正比,为Olgn)。 堆排序   堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征,使得在当前无序区中选取最大(或最小)关键字的记录变得简单。    (1)用大根堆排序的基本思想    先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区    再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换,由此得到新的无序区R[1..n-1]和有序区R[n],且满足R[1..n-1].keys≤R[n].key    由于交换后新的根R[1]可能违反堆性质,故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换,由此得到新的无序区R[1..n-2]和有序区R[n-1..n],且仍满足关系R[1..n-2].keys≤R[n-1..n].keys,同样要将R[1..n-2]调整为堆。   ……   直到无序区只有一个元素为止。    <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1568_2.jpg > 2)大根堆排序算法的基本操作:    初始化操作:将R[1..n]构造为初始堆;    每一趟排序的基本操作:将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换,然后将新的无序区调整为堆(亦称重建堆)。    注意:    只需做n-1趟排序,选出较大的n-1个关键字即可以使得文件递增有序。    用小根堆排序与利用大根堆类似,只不过其排序结果是递减有序的。堆排序和直接选择排序相反:在任何时刻堆排序中无序区总是在有序区之前,且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止 特点   堆排序(HeapSort)是一树形选择排序。堆排序的特点是:在排序过程中,将R[l..n]看成是一棵完全二叉树的顺序存储结构,利用完全二叉树中双亲结点和孩子结点之间的内在关系(参见二叉树的顺序存储结构),在当前无序区中选择关键字最大(或最小)的记录 堆排序与直接选择排序的区别   直接选择排序中,为了从R[1..n]中选出关键字最小的记录,必须进行n-1次比较,然后在R[2..n]中选出关键字最小的记录,又需要做n-2次比较。事实上,后面的n-2次比较中,有许多比较可能在前面的n-1次比较中已经做过,但由于前一趟排序时未保留这些比较结果,所以后一趟排序时又重复执行了这些比较操作。   堆排序可通过树形结构保存部分比较结果,可减少比较次数。 算法分析   堆[排序的时间,主要由建立初始]堆和反复重建堆这两部分的时间开销构成,它们均是通过调用Heapify实现的。    堆排序的最坏时间复杂度为O(nlogn)。堆序的平均性能较接近于最坏性能。    由于建初始堆所需的比较次数较多,所以堆排序不适宜于记录数较少的文件。    堆排序是就地排序,辅助空间为O(1), 它是不稳定的排序方法。

读入一组数据无序多行(数据元素个数少于200万个;且数据元素大小均小于2*10^9

输出一组数据:从小到大输出。 输出可能多行,且每行10个,输出数据元素间使用空隔隔开。

7 10 3 2 7 7 5 11 3 9 12 19 3

2 3 3 3 5 7 7 7 9 10 11 12 19

0

 

 

2017-04-15 21:09:09

10

64

N

2

3

0

1569

种植小树苗

n(1≤n≤100)个同学种n(1≤n≤100)种小树苗。 例如:4个同学(1234)每小时种4种树苗(ABCD)的数量估算如下表所示: <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1569.jpg > 编程输出每人种1种苗所用的总时间最少的安排方案和所花费的时间。

第一行一个整数:n; 表示(1<=n<=100)个同学以及每位同学种n1<=n<=100)小树苗。 接下来共2n+1行, 每行有m个数据,如:第i行表示编号为i-1的同学第小时种植小树苗的数量,数据之间用空隔隔开。

编程输出每人种1种小树苗,且所有人种植的小树苗均不一样,求其所用的总时间花费及安排方案。

4 5 2 4 5 4 3 5 3 5 2 4 2 3 2 3 3

11 2 1 4 3 上述数据说明: 学生1:种植小树苗B;花费时间:2 学生2:种植小树苗A;花费时间:4 学生3:种植小树苗D;花费时间:3 学生4:种植小树苗C;花费时间:2 总时间为:2+4+3+211

0

 

 

2017-04-15 21:09:09

1

64

N

0

1

0

1570

判断字符子串

<img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1570.jpg >

输入共两行: 第一行,输入字符串S 第二行,输入字符串P

检查p是否为s的一个子串。是否存在i值;输出共一行: 输出i

a2da3df22da3fas1232da3 2da3

2

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1571

任意阶幻方构造

任意阶幻方构造方法:   幻方,亦称纵横图。台湾称为魔术方阵。将自然数123……n*n排列成一个n*n方阵,使得每行、每列以及两对角线上的各个数之和都相等,等于n/2*(n*n+1),这样的方阵称为幻方。   例如:把123456789填入3*3的格子,使得:每行、每列、两条对角线的和是15 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1571_1.jpg>   n是它的阶数,比如上面的幻方是3阶。n/2*(n*n+1)为幻方的变幻常数。数学上已经证明,对于n>2n阶幻方都存在。   目前填写幻方的方法,是把幻方分成了三类,每类又有各种各样的填写方法。这里对于这三类幻方,仅举出一种方便手工填写的方法。 1、奇数阶幻方   n为奇数 (n=357911……) (n=2*k+1k=12345……)   奇数阶幻方最经典的填法是罗伯特法(也有人称之为楼梯法)。填写方法是这样:   把1(或最小的数)放在第一行正中; 按以下规律排列剩下的n*n-1个数:   (1)、每一个数放在前一个数的右上一格;   (2)、如果这个数所要放的格已经超出了顶行那么就把它放在底行,仍然要放在右一列;   (3)、如果这个数所要放的格已经超出了最右列那么就把它放在最左列,仍然要放在上一行;   (4)、如果这个数所要放的格已经超出了顶行且超出了最右列,那么就把它放在前一个数的下一行同一列的格内;   (5)、如果这个数所要放的格已经有数填入,处理方法同(4)。   这种写法总是先向右上的方向,象是在爬楼梯。 2、双偶阶幻方   n为偶数,且能被4整除 (n=48121620……) (n=4kk=12345……)   先说明一个定义:   互补:如果两个数字的和,等于幻方最大数和最小数的和,即 n*n+1,称为互补。   先看看4阶幻方的填法:将数字从左到右、从上到下按顺序填写: <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1571_2.jpg>   这个方阵的对角线,已经用蓝色标出。将对角线上的数字,换成与它互补的数字。   这里,n*n+1 = 4*4+1 = 17;   把1换成17-1 = 16;把6换成17-6 = 11;把11换成17-11 = 6……换完后就是一个四阶幻方。   对于n=4k阶幻方,我们先把数字按顺序填写。写好后,按4*4把它划分成k*k个方阵。因为n4的倍数,一定能用4*4的小方阵分割。然后把每个小方阵的对角线,象制作4阶幻方的方法一样,对角线上的数字换成互补的数字,就构成幻方。   下面是8阶幻方的作法:   (1) 先把数字按顺序填。然后,按4*4把它分割成2*2个小方阵 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1571_3.jpg>   (2) 每个小方阵对角线上的数字,换成和它互补的数。 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1571_4.jpg> 3、单偶阶幻方   n为偶数,且不能被4整除 (n=610141822……) (n=4k+2k=12345……)   这是三种里面最复杂的幻方。   以n=10为例。这时,k=2   (1) 把方阵分为ABCD四个象限,这样每一个象限肯定是奇数阶。用楼梯法,依次在A象限,D象限,B象限,C象限按奇数阶幻方的填法填数。 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1571_5.jpg> <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1571_6.jpg>   (2) A象限的中间行、中间格开始,按自左向右的方向,标出k格。A象限的其它行则标出最左边的k格。 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1571_7.jpg>   (3) 将这些格,和C象限相对位置上的数,互换位置。 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1571_8.jpg>   (4) B象限任一行的中间格,自右向左,标出k-1列。(注:6阶幻方由于k-1=0,所以不用再作BD象限的数据交换) <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1571_9.jpg>   (5) B象限标出的这些数,和D象限相对位置上的数进行交换,就形成幻方。 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1571_10.jpg>

读入一行,幻方的阶:n

输出幻方: 共n行,每行n个数,数据之间用空隔隔开。

5

17 24 1 8 15 23 5 7 14 16 4 6 13 20 22 10 12 19 21 3 11 18 25 2 9

0

 

 

2017-04-15 21:09:09

1

64

N

0

1

0

1572

计数排序设计

<img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1572.jpg> 根据上述程序:修改程序代码,根据输出要求,重新设计程序功能!最后,成为从小到大的排序。

第一行,一个整数n1<=n<=1000000);表示数据元素的个数。 第二行,接下来共n个整数。

第一行,共n个数据,输出统计的结果; 第二行,共n个数据:根据统计结果,从小到大输出n个元素。

10 5 34 6 8 9 23 35 78 6 10

9 2 7 6 5 3 1 0 7 4 5 6 6 8 9 10 23 34 35 78

0

 

 

2017-04-15 21:09:09

1

64

N

0

1

0

1573

【培训习题.分治】数的查找

对于n个元素的数组a[1..n],要求从中找出第K小的元素。(元素n的个数取决于实际情况:数据系列A大小。)

第一行是整数k:表示要找出下面系列A中第K小的元素。 接下来是系列A,具体元素个数取决于实际情况。可能存在多行。

求第K小的数在系列A中,所处在的实际位置。

3 23 8 91 56 4

1

0

 

 

2017-04-15 21:09:09

1

64

N

0

1

0

1574

【培训习题.分治】求逆序对数

给出n个数的序列A,A中的数据任意排列,无序!) 定义逆序对:(i, j)为满足:i<j, A[i] > A[j](左边的元素大) 求出序列A中,存在的逆序对的个数。

4 3 2 1 5

6

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

0

0

0

1575

USACO_3.4.1Closed Fences闭合的栅栏

一个闭合的栅栏是平面上的一些不相交的首尾相连的线段形成的多边形,有N个角(顶点) (3 < N < 200)。 顶点不重合,它以逆时针方式以数组{xi, yi}给出(i=1,2,...,N) <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1575.jpg > 请编写一个程序实现下面的任务: 检查输入的顶点列表{xi,yi}, i=1,2,...,N, 判断它是否为一个合法的闭合栅栏。 找出所有可以被站在点(x,y)处的人所能看到的栅栏(忽略人的高度),因为有的栅栏会被另外的栅栏所挡住。 只有当存在从(x,y)发射的一条射线第一个穿过栅栏i时,栅栏i是可以被看见的。如果栅栏是平行于目光的,它并不认为是可以看见的。在上面的例子里,线段[x3,y3]-[x4,y4], [x5,y5]-[x6,y6], [x6-y6]-[x1,y1]是可以被(x,y)看见的。

PROGRAM NAME: fence4 INPUT FORMAT: (file fence4.in) 第一行: N, 表示闭合栅栏的顶点数。 第二行: 两个整数xy,表示观测者的位置。两个整数都是16位的。即2^16,在longlonglongint范围内。 第3N+2: 每行一对整数(x,y)表示对应闭合栅栏的第k个顶点的坐标。坐标以逆时针顺序给出。整数绝对值不超过1000。 注意:我添加了该题的新的第12个测试点。如果你认为这个点的数据是错误的,发送邮件到Robkolstad@ace.delos.com)在您的邮件主题中一定要包括USACO

(file fence4.out) 如果给出的序列不是一个合法的闭合栅栏,那么输出文件只需要输出“NOFENCE”。 栅栏用两端的顶点表示,顶点的输出顺序以输入文件中的顺序为准。把栅栏按照最后一个点在输入文件中的顺序排序。如果两条栅栏的最后一个点是一样的,就以它们第一个点的顺序排序。

13 5 5 0 0 7 0 5 2 7 5 5 7 3 5 4 9 1 8 2 5 0 9 -2 7 0 3 -3 1

7 0 0 7 0 5 2 7 5 7 5 5 7 5 7 3 5 -2 7 0 3 0 0 -3 1 0 3 -3 1

0

 

USACO_3.4.1Closed Fences闭合的栅栏

2017-04-15 21:09:09

1

64

N

1

1

0

1576

USACO_3.4.2American Heritage美国血统

农夫约翰非常认真地对待他的奶牛们的血统。然而他不是一个真正优秀的记帐员。他把他的奶牛们的家谱作成二叉树,并且把二叉树以更线性的树的中序遍历树的前序遍历的符号加以记录而不是用图形的方法。 你的任务是在被给予奶牛家谱的树中序遍历树前序遍历的符号后,创建奶牛家谱的树的后序遍历的符号。每一头奶牛的姓名被译为一个唯一的字母。(你可能已经知道你可以在知道树的两种遍历以后可以经常地重建这棵树。)显然,这里的树不会有多于26个的顶点。这是在样例输入和样例输出中的树的图形表达方式: <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1576.jpg > 树的中序遍历是按照左子树,根,右子树的顺序访问节点。 树的前序遍历是按照根,左子树,右子树的顺序访问节点。 树的后序遍历是按照左子树,右子树,根的顺序访问节点。

PROGRAM NAME: heritage INPUT FORMAT: (file heritage.in) 第一行: 树的中序遍历 第二行: 同样的树的前序遍历

OUTPUT FORMAT: (file heritage.out) 单独的一行表示该树的后序遍历。

ABEDFCHG CBADEFGH

AEFDBHGC

0

 

USACO_3.4.2American Heritage美国血统

2017-04-15 21:09:09

1

64

N

2

3

0

1577

USACO_3.4.3Electric Fences电网

在本题中,格点是指横纵坐标皆为整数的点。 为了圈养他的牛,农夫约翰建造了一个三角形的电网。他从原点(0,0)牵出一根通电的电线,连接格点(n,m)0<=n<32000,0<m<32000),再连接格点(p,0)p>0),最后回到原点。 牛可以在不碰到电网的情况下被放到电网内部的每一个格点上(十分苗条的牛)。如果一个格点碰到了电网,牛绝对不可以被放到该格点之上。那么有多少头牛可以被放到农夫约翰的电网中去呢?

PROGRAM NAME: fence9 INPUT FORMAT: (file fence9.in) 输入文件只有一行,包含三个用空格隔开的整数:n,mp

OUTPUT FORMAT: (file fence9.out) 输出文件只有一行,包含一个整数,代表能被指定的电网包含的牛的数目。

7 5 10

20

0

 

USACO_3.4.3Electric Fences电网

2017-04-15 21:09:09

1

64

N

3

3

0

1578

USACO_3.4.4Raucous Rockers“破锣摇滚乐队

你刚刚继承了流行的破锣摇滚乐队录制的尚未发表的N(1 <= N <= 20)首歌的版权。你打算从中精选一些歌曲,发行M(1 <= M <= 20)CD。每一张CD最多可以容纳T(1 <= T <= 20)分钟的音乐,一首歌不能分装在两张CD中。 不巧你是一位古典音乐迷,不懂如何判定这些歌的艺术价值。于是你决定根据以下标准进行选择: 1.歌曲必须按照创作的时间顺序在CD盘上出现。 2.选中的歌曲数目尽可能地多。 3.不仅同光盘上的歌曲写入时间要按顺序,前一张光盘上的歌曲不能比后一张歌曲写入时间要晚。

PROGRAM NAME: rockers INPUT FORMAT: (file rockers.in) 第一行: 三个整数:N, T, M. 第二行: N个整数,分别表示每首歌的长度,按创作时间顺序排列。

OUTPUT FORMAT: (file rockers.out) 一个整数,表示可以装进MCD盘的乐曲的最大数目。

4 5 2 4 3 4 2

3

0

 

USACO_3.4.4Raucous Rockers“破锣摇滚乐队

2017-04-15 21:09:09

1

64

N

3

3

0

1579

USACO教程 4.1Optimization最优化

Advanced algorithms and difficult drills(高级算法与困难的习题) 目录 [隐藏] 1 什么是最优化? 2 一个问题:链 3 优化的基础 4 链问题的优化 什么是最优化? 让你的工作代码更快 注意你的工作。在你的程序工作之前,不要试图让它变得更快,因为调试查错可能将更为复杂。在为了优化(而不是调试查错)而对程序作出任何更改之前,给你的代码做一下备份。当你作出了3种深层次的优化之后,发现第一次的优化破坏了程序的正确性,而此时你又没有任何备份可以恢复之前的正确程序,没有再比这更为痛苦的事了。 这块内容将注意几种能加速程序而不更改算法的方法。当然如果有更快的算法,则你的思考方向就应该是思考那种算法,而不是让一种本来就很慢的算法快那么一小点,这就像在猪身上使用香水一样。(USACO这个比喻有点......) 尤其值得注意的是,本模块内容仅将讨论使递归下降程序变得更快的方法,尝试避免搜索整棵树。这种方法通常被归为搜索的剪枝。 一个问题:链 这是一个在编译器中的现实问题,虽然在那个世界中只有乘法是可用的。 假设一个程序需要精确地得到x^n的值,而标准操作只有乘和除(没有 log/exp)。这些操作最少需要多少次?按次序输出为得到x^n所需要计算的x的幂值。 为了说明这个问题,以下给出的计算过程将仅表现指数,乘法将被表示为加法(两个指数的和),除法将被表示为减法(两个指数的差)。在合法的链中,每个指数都将是两个已得出的指数的和或差。所以计算x^8的序列将表示为:1 2 4 8;计算x^15的序列可以表示为:1 2 4 8 16 15 Test Set #1 考虑计算集合[1..50]内的数据。所有时间将在233MHzPentium II处理器上得到。 一个基本的算法 从1开始,进行深度优先搜索。 出现了什么问题? 这个程序将永远不会终止。 所以需要改变算法以减少生成比答案更长的数列的次数。假设最长链的长度为32,为实现例子所需的运行时间达到了4658.34秒。 优化的基础 更早地剪枝,更频繁地剪枝 思考:在一棵输出2的搜索树中,避免搜索出超过4个节点。 两个能使搜索更快的基本思想: 不要做任何愚蠢的事 不要把事情做两遍 问题在于如何找到进行了两遍的事,什么是愚蠢的事。这里所有的优化操作都建立在计算正确的前提下,你要保证你的程序是正确的。 链问题的优化 Observation #1 有一种简单的方法可以先确定出一个数,或者纯粹是先得一个搜索的最大值。计算n的二进制表示形式,首先不断生成2的幂值,再将这些生成的数相加得到n。 举例说:n=43,则它的二进制形式为101011。因此,首先的到的数列为:1 2(10) 4(100) 8(1000) 16(10000) 32(100000),所以计算1+2=3(11)3+8=11(1011)11+32=43(101011)。故输出数列:1 2 4 8 16 32 3 11 43。至少可以先得到一个最优解。 而这个程序的运行时间为4609.81秒。 评价:这只是勉强可以算是优化。虽然这避免了很多不必要的计算,但在一棵如此巨大的搜索树中确实不能起到太大作用。 Observation #2 出现负数显然是愚蠢的,不要让它们出现在数列中。(证明过程略...) 现在新的运行时间为387.34秒。 出现0甚至更愚蠢。(证明过程略...) 新的运行时间:43.24秒。 评价:两个简单的操作减少了100倍数量级地运算时间,并且它们的代码非常容易写,这非常好地体现了优秀的优化。 Observation #3 在一步操作中,可能生成的最大整数是当前已生成的序列中最大数的2倍,所以,如果当前最大值乘以 2^到达当前最优解的剩余操作数 小于目标,那么,停止。 运行时间:0.15秒。 增加数据规模 目前程序很快,我们应该增加数据规模了。新的数据中幂不大于300,运行时间是93.21秒。 注意4 为什么不使用迭代加深搜索呢?这个搜索的分支系数很大,随着深度的增加结点数成指数级增长,所以进行迭代加深搜索所进行的多余运算相对而言是很少的。 运行时间: 93.05秒。 评价:既然这样,从数据看这是一个不强的优化(慢慢会好起来)。它使程序代码产生了很大的改变,出错的机会增加了,还没有带来任何好处。这令我们有点惊讶,它一向有很大作用。 注意5 最近的操作必须使用倒数第二个数。如果不用,生成它干什么? (现在就呈现出可变下界深度优先搜索算法)。 运行时间: 7.47 秒 。 注意6 不要复制已有的数。 运行时间:3.40 秒 检查 这样, 除了可变下界深度优先搜索以外,只有“Don't Do Anything Stupid”这一原则被体现了,执行时间减少了约842,510倍。这是好的,但也许可以再提高。 增加数据规模 新的数据中幂不大于500,运行时间是206.71秒。 注意7 如果一个数列的前缀没有得到解,在后面加什么数也没有用。例如,如果1 2 4 8 7得不到解,就不用尝试1 2 4 8 16 7了。 运行时间: 53.70 秒 注意8 如果选择了i,数列中最大的数是j,而且i+j小于下一个需要的数,那就不要选择i。 运行时间: 44.52 秒。 注意9 如果一个数列生成 x (x不是目标)用了j项,而且存在另外一个数列用了少于j项,我们应该用这个短的数列把它替换掉,获得一个更好的数列,这是最佳的。 错误! 第一个反例: 10,127.用这种方法得到的解是17项,但是存在一个16项的方法。 这就是优化的风险:有时候,会得到错误结论。确保你不会掉入陷阱. 总结 8个优化使运行时间缩小400万倍。可以使不大于500的数据在44.52秒内出解。有的程序可以在640k内存限制的情况下1.91秒内出解(无限制时0.85)。看看你的程序有多快。 来自“http://www.nocow.cn/index.php?title=Translate:USACO/Optimization&oldid=30735”

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

3

3

0

1580

USACO_4.1.1Beef McNuggets麦香牛块

农夫布朗的奶牛们正在进行斗争,因为它们听说麦当劳正在考虑引进一种新产品:麦香牛块。奶牛们正在想尽一切办法让这种可怕的设想泡汤。奶牛们进行斗争的策略之一是劣质的包装看,奶牛们说,如果你只用一次能装3块、6块或者10块的三种包装盒包装麦香牛块,你就不可能满足一次只想买1245781114或者17块麦香牛块的顾客了。劣质的包装意味着劣质的产品。你的任务是帮助这些奶牛。给出包装盒的种类数N(1<=N<=10)N个代表不同种类包装盒容纳麦香牛块个数的正整数(1<=i<=256),输出顾客不能用上述包装盒(每种盒子数量无限)买到麦香牛块的最大块数。如果所有购买方案都能得到满足或者不存在不能买到块数的上限,则输出0。不能买到的最大块数(倘它存在)不超过2,000,000,000

PROGRAM NAME: nuggets INPUT FORMAT: (file nuggets.in) 1: 包装盒的种类数N 2行到N+1: 每个种类包装盒容纳麦香牛块的个数

OUTPUT FORMAT: (file nuggets.out) 输出文件只有一行数字:顾客不能用包装盒买到麦香牛块的最大块数或0(如果所有购买方案都能得到满足或者顾客不能买到的块数没有上限)

3 3 6 10

17

0

 

USACO_4.1.1Beef McNuggets麦香牛块

2017-04-15 21:09:09

1

64

N

1

3

0

1581

USACO_4.1.2Fence Rails栅栏的木料

农民John准备建一个栅栏来围住他的牧场。他已经确定了栅栏的形状,但是他在木料方面有些问题。当地的杂货储存商扔给John一些木板,而John必须从这些木板中找出尽可能多所需的木料。   当然,John可以切木板。因此,一个9英尺的木板可以切成一个5英尺和一个4英尺的木料 (当然也能切成33英尺的,等等)John有一把梦幻之锯,因此他在切木料时,不会有木料的损失。   所需要的木料规格都已经给定。你不必切出更多木料,那没有用。

INPUT FORMAT 1: N (1 <= N <= 50), 表示提供的木板的数目 第2行到第N+1: N行,每行包括一个整数,表示各个木板的长度。 第N+2: R (1 <= R <= 1023), 所需木料的数目 第N+3行到第N+R+1: R行,每行包括一个整数(1 <= ri <= 128)表示所需木料的长度。

OUTPUT FORMAT    只有一行,一个数字,表示能切除的最多的所需木料的树木。当然,并不是任何时候都能切出所有所需木料。

SAMPLE INPUT (file fence8.in) 4 30 40 50 25 10 15 16 17 18 19 20 21 25 24 30

SAMPLE OUTPUT (file fence8.out) 7

0

 

 

2017-04-15 21:09:09

1

64

N

0

2

0

1582

USACO_4.1.3Fence Loops篱笆回路

农夫布朗的牧场上的篱笆已经失去控制了。它们分成了1~200英尺长的线段。只有在线段的端点处才能连接两个线段,有时给定的一个端点上会有两个以上的篱笆。结果篱笆形成了一张网分割了布朗的牧场。布朗想将牧场恢复原样,出于这个考虑,他首先得知道牧场上哪一块区域的周长最小。 布朗将他的每段篱笆从1N进行了标号(N=线段的总数)。他知道每段篱笆的有如下属性: 该段篱笆的长度 该段篱笆的一端所连接的另一段篱笆的标号 该段篱笆的另一端所连接的另一段篱笆的标号 幸运的是,没有篱笆连接它自身。 对于一组有关篱笆如何分割牧场的数据,写一个程序来计算出所有分割出的区域中最小的周长。 例如,标号1~10的篱笆由下图的形式组成(下面的数字是篱笆的标号): <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1582.jpg> 上图中周长最小的区域是由278号篱笆形成的。 PROGRAM NAME: fence6

INPUT FORMAT 1: N (1 <= N <= 100) 2行到第3*N+1: 每三行为一组,共N组信息: 每组信息的第1行有4个整数: s, 这段篱笆的标号(1 <= s <= N); Ls, the这段篱笆的长度 (1 <= Ls <= 255); N1s (1 <= N1s <= 8) 与本段篱笆的一端所相邻的篱笆的数量; and N2s与本段篱笆的另一端所相邻的篱笆的数量。 (1 <= N2s <= 8). 每组信息的的第2行有 N1s个整数, 分别描述与本段篱笆的一端所相邻的篱笆的标号。 每组信息的的第3行有N2s个整数, 分别描述与本段篱笆的另一端所相邻的篱笆的标号。

OUTPUT FORMAT 输出的内容为单独的一行,用一个整数来表示最小的周长。

SAMPLE INPUT (file fence6.in) 10 1 16 2 2 2 7 10 6 2 3 2 2 1 7 8 3 3 3 2 1 8 2 4 4 8 1 3 3 9 10 5 5 8 3 1 9 10 4 6 6 6 1 2 5 1 10 7 5 2 2 1 2 8 9 8 4 2 2 2 3 7 9 9 5 2 3 7 8 4 5 10 10 10 2 3 1 6 4 9 5

SAMPLE OUTPUT (file fence6.out) 12

0

 

 

2017-04-15 21:09:09

1

64

N

0

1

0

1583

USACO_4.1.4Cryptcowgraphy解密牛语

农民BrownJohn的牛们计划协同逃出它们各自的农场。它们设计了一种加密方法用来保护它们的通讯不被他人知道。 如果一头牛有信息要加密,比如"International Olympiad in Informatics",它会随机地把COW三个字母插到到信息中(其中CO前面,OW前面),然后它把CO之间的文字和 OW之间的文字的位置换过来。这里是两个例子: International Olympiad in Informatics -> CnOIWternational Olympiad in Informatics International Olympiad in Informatics -> International Cin InformaticsOOlympiad W 为了使解密更复杂,牛们会在一条消息里多次采用这个加密方法(把上次加密的结果再进行加密)。一天夜里,John的牛们收到了一条经过多次加密的信息。请你写一个程序判断它是不是这条信息经过加密(或没有加密)而得到的: Begin the Escape execution at the Break of Dawn PROGRAM NAME:cryptcow

INPUT FORMAT 一行,不超过75个字符的加密过的信息。

OUTPUT FORMAT 一行,两个整数. 如果能解密成上面那条逃跑的信息,第一个整数应当为1,否则为0; 如果第一个数为1,则第二个数表示此信息被加密的次数,否则第二个数为0

SAMPLE INPUT(file cryptcow.in) Begin the EscCution at the BreOape execWak of Dawn

SAMPLE OUTPUT(file cryptcow.out) 1 1

0

 

 

2017-04-15 21:09:09

1

64

N

0

1

0

1584

USACO_4.1.5Arithmetic Progressions等差数列

一个等差数列是一个能表示成a, a+b, a+2b,..., a+nb (n=0,1,2,3,...) 在这个问题中a是一个非负的整数,b是正整数。 写一个程序来找出在双平方数集合S中长度为n的等差数列。 双平方数集合是所有能表示成p^2q^2的数的集合。(数据p的平方与数据q的平方和) PROGRAM NAME: ariprog

第一行: N(3<= N<=25),要找的等差数列的长度。 第二行: M(1<= M<=250),搜索双平方数的上界0 <= p,q <= M

如果没有找到数列,输出`NONE'。 如果找到了,输出一行或多行, 每行由于二个整数组成:a,b 这些行应该先按b排序再按a排序。 将不会有只多于10,000个等差数列。

SAMPLE INPUT (file ariprog.in) 5 7

SAMPLE OUTPUT (file ariprog.out) 1 4 37 4 2 8 29 8 1 12 5 12 13 12 17 12 5 20 2 24

0

 

USACO_4.1.5

2017-04-15 21:09:09

1

64

N

0

0

0

1585

USACO教程 4.2Network Flow网络流

目录 1 问题预备 2 问题 2.1 算法 2.2 实例 2.3 扩展 3 可选问题 3.1 最大匹配 3.2 最小割 3.3 例题 3.3.1 病毒流 3.3.2 伐木工人的计划 3.3.3 牛的电话联系(USACO 锦标赛 1996 3.3.4 科学展览审定 3.3.5 石油管道设计 问题预备 最短路 问题 给出一个有向连通带权图,包含源点和汇点。 每一条弧的权表示那条弧的容量。一个图的流通过分配整数量给每条边来达到 通过每条弧的流不大于这条弧的容量 除了源点和汇点的每个点,流入量等于流出量 使源点的流出总量减去流入总量(或汇点的流入总量减去流出总量)最大 例 给出水管的设计和每条水管的容量。水管里的水必须从上往下流,所以每条水管里,水只能向一个方向流。 计算能从头(自来水厂)流到尾(您的农场)的水量。 算法 算法(贪心)通过迭代增加从源到汇的流来建立网络流。 从每条弧的权等于初始的权开始(弧的权符合那条弧里还未使用的容量)。 给出当前的图,找到从源到汇的一条路径,这条路径上的弧都是非0权。计算这条路径的最大流,叫它路径容量。//增广路径 + 路径容量 = 瓶颈容量 对于每一条路径上的弧,给弧的权减去路径容量。另外,给路径中的反向弧(在相同两点之间的弧,不过方向相反)加上等于和路径容量相等的权(只要反向弧存在,就增加它的权)。//调整增广路径 继续调整路径直到没有增广路径存在。 这能保证停止,因为您加上每次至少一单位流(权总是整数),并且流严格单调递增。增加反向弧的权相当于减少路径上的流量。 如果您对算法的细节分析感兴趣,请向Sedgewick请教(注:Robert Sedgewick 普林斯顿大学的计算机科学教授). 这是算法的伪代码 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1585_0.jpg> 这个方法的运行时间为O(FM)F是最大流 M是弧的数目. 运行时间通常更短, 因为算法每次总是尽可能大的提升流。 为了确定每条弧上的流,比较开始的容量和最后的容量。如果最后的容量变少了,区别就在于通过这条弧的流。 当有回路的时候,这个算法可能产生死循环。 实例 考虑下面那个网络,源点为5,汇点为2 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1585_1.jpg> <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1585_2.jpg> <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1585_3.jpg> 扩展 网络流问题是很广泛的,通常和图结合在一起。 扩展到无向图,只需要简单的把无向边扩展为两条相反方向的弧就可以了。 如果您想要限制任意一个节点的通过量,把一个节点拆成两个,一个流入节点,一个流出节点,把流入的弧连到流入节点里,流出弧连到流出节点里,在流入节点和流出节点之间加上一条弧,容量为限制。 如果您有多源点汇点,建立一个虚拟的源点和虚拟的汇点,虚拟的源点射出弧到每个源点,汇点射出弧到虚拟汇点。容量无限。 如果您有实数型的权,这个问题不再保证能出解,尽管答案能逐渐逼近。 可选问题 网络流能用来解决其他的一些不明显的问题。 最大匹配 给出两个对象集合(叫他们AB),你想要把AB中的元素尽可能多的匹配起来,约束条件是只可以两两配对。这就是最大匹配问题。 把这个问题用网络流的形式表现出来,建立一个源点,射出容量为1的弧给A的元素,建立一个汇点,从B中的元素射出容量为1的弧到此汇点。另外,如果A中某个元素可 以和B中某个元素匹配,从A的这个元素向B的那个元素射出一条容量为1的弧。用网络流算法确定哪些A元素到B元素的弧被用到。 最小割 给出一个带权无向图,最小割就是一个权和最小的,能够把两个给出点分开的边的集合。 最小的权和就是两个节点之间的流。 要确定路径,按照权递增的顺序尝试删除每条边,看它是否减少了网络流(如果减少了,减少量应为边的容量)。第一个这样的边就是最小割的元素,去掉这条边继续在图上操作。 用相同的技巧,把节点用容量限制,这能够扩展到求节点的割。有向图也是一样。然而,它不能够解决所谓的最佳匹配问题,每一对都有一个佳值,而且您想要得到最高佳值和的匹配。 例题 如果问题讨论取流或者其他从一个地方到另一个地方东西的移动的最优值,就可以几乎确定是最大流。如果它讨论的是将两个物料项目以最小代价分隔开的问题,就可能是最小割。如果它讨论的任何一类东西的最大配对,就可能是最大匹配。 病毒流 您有一个通过网线连接的计算机网络。数据可能从任何一个方向流经网线。不幸的是,一台网络里的机器染上病毒,您需要从中心服务器隔离这台机器来防止病毒传染。给出关闭一对机器连接的代价,计算控制病毒传染到服务器的最小的代价。 这就是最小割问题。 伐木工人的计划 不同种类的树需要雇佣拥有不同的技巧的伐木工人来正确的砍树。不管哪种树或伐木工人,砍一棵树需要30分钟。给出伐木工人的信息,和哪种树需要哪位才能正确的砍倒,以及树的信息,计算在半小时内砍倒的最多的树的数目。对于每一个伐木工人,都有一种对应的他(她)能砍倒的树。所以,这个问题能用最大匹配算法来解决。 牛的电话联系(USACO 锦标赛 1996) 给出特定区域里的一组电脑,和电脑之间连着的网线,要想阻止给定两台电脑的联系 最少需要关掉多少网络中的电脑。假定两台给出的电脑没有关掉。 这相当于最少节点割的问题。两台给出的电脑标上源点和汇点。电缆是双向的。把每个点拆成流入点和流出点,这样我们就能够用1限制任何一台电脑。现在,网络里的最大流就相当于节点最小割了。 为了具体确定割,反复删除节点,直到您找到一个能降低网络流量的节点。 科学展览审定 一个科学展览由N个学科,和M个裁判。每个裁判愿意审定某些学科,每个学科需要一些裁判。每个裁判只能够审定在给出的科学展览中的一个学科。您在这些条件下总共能分配给多少裁判任务? 这是一个很类似最大匹配的问题,除了每个学科需要可能多于一个裁判。解决这个问题的最简单的方法是把从科目到汇点的弧的容量赋予需要裁判数的值。 石油管道设计 给出阿拉斯加管道线的设计(每条管道的容量,和管道如何连接),以及每个交点的位置,您想提高朱诺和费尔班柯斯之间最大流量,但您的钱只够添加一条容量为X的管道。此外,管道只能10英里长。这条管道添加在哪两个交点能最大程度的提高流量? 要解决这个问题,对于距离10英里以内的每一对交点,添加一条管道,再计算从朱诺到费尔班柯斯的流量增加值。每一个子问题都是最大流。

 

 

 

 

0

 

 

2017-04-15 21:09:09

1

64

N

1

1

0

1586

USACO_4.2.1Drainage Ditches 草地排水

在农夫约翰的农场上,每逢下雨,Bessie最喜欢的三叶草地就积聚了一潭水。这意味着草地被水淹没了,并且小草要继续生长还要花相当长一段时间。因此,农夫约翰修建了一套排水系统来使贝茜的草地免除被大水淹没的烦恼(不用担心,雨水会流向附近的一条小溪)。作为一名一流的技师,农夫约翰已经在每条排水沟的一端安上了控制器,这样他可以控制流入排水沟的水流量。 农夫约翰知道每一条排水沟每分钟可以流过的水量,和排水系统的准确布局(起点为水潭而终点为小溪的一张网)。需要注意的是,有些时候从一处到另一处不只有一条排水沟。 根据这些信息,计算从水潭排水到小溪的最大流量。对于给出的每条排水沟,雨水只能沿着一个方向流动,注意可能会出现雨水环形流动的情形。

PROGRAM NAME:ditch INPUT FORMAT: (file ditch.in) 1: 两个用空格分开的整数N (0 <= N <= 200)  M (2 <= M <= 200)N是农夫John已经挖好的排水沟的数量,M是排水沟交叉点的数量。交点1是水潭,交点M是小溪。 第二行到第N+1: 每行有三个整数,Si, Ei,  CiSi  Ei (1 <= Si, Ei <= M) 指明排水沟两端的交点,雨水从Si 流向EiCi (0 <= Ci <= 10,000,000)是这条排水沟的最大容量。

OUTPUT FORMAT: (file ditch.out) 输出一个整数,即排水的最大流量。

5 4 1 2 40 1 4 20 2 4 20 2 3 30 3 4 10

50

0

 

USACO_4.2.1

2017-04-15 21:09:09

1

64

N

1

1

0

1587

USACO_4.2.2The Perfect Stall 完美的牛栏

农夫约翰上个星期刚刚建好了他的新牛棚,他使用了最新的挤奶技术。不幸的是,由于工程问题,每个牛栏都不一样。第一个星期,农夫约翰随便地让奶牛们进入牛栏,但是问题很快地显露出来:每头奶牛都只愿意在她们喜欢的那些牛栏中产奶。上个星期,农夫约翰刚刚收集到了奶牛们的爱好的信息(每头奶牛喜欢在哪些牛栏产奶)。一个牛栏只能容纳一头奶牛,当然,一头奶牛只能在一个牛栏中产奶。 给出奶牛们的爱好的信息,计算最大分配方案。 PROGRAM NAME: stall4

INPUT FORMAT: (file stall4.in) 第一行 两个整数,N (0 <= N <= 200)  M (0 <= M <= 200) N 是农夫约翰的奶牛数量,M 是新牛棚的牛栏数量。 第二行到第N+1行 一共 N 行,每行对应一只奶牛。第一个数字 (Si) 是这头奶牛愿意在其中产奶的牛栏的数目 (0 <= Si <= M)。后面的 Si 个数表示这些牛栏的编号。牛栏的编号限定在区间 (1..M) 中,在同一行,一个牛栏不会被列出两次。

(file stall4.out) 只有一行。输出一个整数,表示最多能分配到的牛栏的数量.

5 5 2 2 5 3 2 3 4 2 1 5 3 1 2 5 1 2

4

0

 

USACO_4.2.2

2017-04-15 21:09:09

1

64

N

0

0

0

1588

【分区联赛模拟试题1_1.漂亮字串】

Caima认为OX是最优美的两个字母,由OX组成的串是最优美的串。 在这些最优美的串中,如果任意只包含X的子串,长度不超过maxX,任意只包含O的子串,长度不超过maxO,而整个串最多有countOOcountXX。那么这个就是超级优美无敌串。 现在Caima想知道最长的超级优美无敌串有多长,希望你告诉他。

输入包含多行,至文件结束为止; 每行四个数,依次是CountOCountX,maxOmaxX

每组数据输出一行,一个数表示最长的超级优美无敌串的长度。 【数据规模】 0<=CountOCountX,maxOmaxX<=1000000

10 10 0 0 3 5 1 1

0 7

0

【注意事项】 第二个样例的解释:“XOXOXOX” 最多1000组数据,其中30%的数据0<=CountOCountX,maxOmaxX<=20,且数据组数不超过20组。

【分区联赛模拟试题1_1.漂亮字串】

2017-04-15 21:09:09

1

128

N

1

1

0

1589

【分区联赛模拟试题1_2.Set

现在给你一些连续的整数,它们是从AB的整数。一开始每个整数都属于各自的集合,然后你需要进行一下的操作: 每次选择两个属于不同集合的整数,如果这两个整数拥有大于等于P的公共质因数,那么把它们所在的集合合并。 反复如上操作,直到没有可以合并的集合为止。 现在Caima想知道,最后有多少个集合。

一行,三个整数A,B,P。 【数据规模】 A≤B≤100000 2≤P≤B

一个数,表示最终集合的个数。

10 20 3

7

0

【注意事项】 有80%的数据B≤1000。 样例解释{10,20,12,15,18}{13}{14}{16}{17}{19}

【分区联赛模拟试题1_2.Set

2017-04-15 21:09:09

1

128

N

1

2

0

1590

【分区联赛模拟试题1_3.Prison

Caima王国中有一个奇怪的监狱,这个监狱一共有P个牢房,这些牢房一字排开,第i个紧挨着第i+1个(最后一个除外)。现在正好牢房时满的。 上 级下发了一个释放名单,要求每天释放名单上的一个人。这可把看守们吓得不轻,因为看守们知道,现在牢房中的P个人,可以相互之间传话。如果某个人离开了,那么原来和这个人能说上话的人,都会很气愤,导致他们那天会一直大吼大叫,搞得看守很头疼。如果给这些要发火的人吃上肉,他们就会安静点。

第一行两个数PQQ表示释放名单上的人数; 第二行Q个数,表示要释放哪些人。 【数据规模】 1≤P≤1000 1≤Q≤100 【注意事项】 Q≤P;且50%的数据 1≤P≤1001≤Q≤5

仅一行,表示最少要给多少人次送肉吃。

20 3 3 6 14

35

0

【注意事项】 Q≤P;且50%的数据 1≤P≤1001≤Q≤5

【分区联赛模拟试题1_3.Prison

2017-04-15 21:09:09

1

128

N

1

1

0

1591

【分区联赛模拟试题1_4.Tree

给一棵树,你可以匹配有边相连的两个点,问你这棵树的最大匹配时多少,并且计算出有多少种最大匹配。

第一行一个数N,表示有多少个结点。 接下来N行,每行第一个数,表示要描述的那个结点。然后一个数m,表示这个结点有m个儿子,接下来m个数,表示它的m个儿子的编号。 【数据规模】 N≤1000,其中40%的数据答案不超过10^8

输出两行,第一行输出最大匹配数,第二行输出最大匹配方案数。

7 1 3 2 4 7 2 1 3 4 1 6 3 0 7 1 5 5 0 6 0

3 4

0

 

【分区联赛模拟试题1_4.Tree

2017-04-15 21:09:09

1

128

N

0

0

0

1592

【分区联赛模拟试题2_1.倒水】

一天,树树买了N个容量可以认为是无限大的瓶子,初始时每个瓶子里有1升水。树树发现瓶子实在太多了,于是他决定保留不超过K个瓶子。每次他选择两个当前含水量相同的瓶子合并,把一个瓶子的水全部倒进另一个瓶,然后把空瓶丢弃(不能丢弃有水的瓶子)。 显然在某些情况下树树无法达到目标,你如N=3K=1。此时树树会重新买一些新的瓶子(新瓶子容量无限,开始时有1升水),以达到目标。 现在树树想知道,最少需要买多少新瓶子才能达到目标呢?

一行两个正整数N,K1≤N≤10^9K≤1000)。 【数据规模】 对于30%数据,N≤3*10^5; 对于100%的数据如题目。

一个非负整数,表示最少需要买多少新瓶子。

3 1

1

0

【数据规模】 对于30%数据,N≤3*10^5; 对于100%的数据如题目。

【分区联赛模拟试题2_1.倒水】

2017-04-15 21:09:09

1

64

N

3

3

0

1593

【分区联赛模拟试题2_2.单词缩写】

树树发现好多计算机中的单词都是缩写的,如GDB,它是全称Gnu DeBug的缩写。但是,有时缩写对应的全称会不固定,如缩写LIUNUX,可以理解为: (1 LINus’s UniX 2 LINUs’s miniX 3 Linux Is Not Unix 现在树树给出一个单词缩写,以及一个固定的全称(若干个单词组成,空格隔开)。全称中可能会有无效的单词,需要忽略掉,一个合法缩写要求每个有效单词至少有一个字符出现在缩写中,缩写必须按顺序出现在全称中。 对于给定的缩写和一个固定的全称,问有多少种解释方法?解释方法为缩写的每个字母在全称每个有效单词中出现的位置,有一个字母位置不同,就认为是不同的解释方法。

第一行输入一个N,表示有N个无效单词; 接下来N行分别描述一个有小写字母组成的无效单词; 最后是若干个询问,先给出缩写(只有大写字母),然后给出一个全称,读入以"LAST CASE"结束。 【数据规模】 1≤N≤100,每行字符串长度不超过150,询问不超过20,最后方案数不超过10^9

对于每个询问先输出缩写,如果当前缩写不合法,则输出"is not a valid abbreviation", 否则输出"can be formed in i ways"i表示解释方法种数)。

2 and of ACM academy of computer makers RADAR radio detection and ranging LAST CASE

ACM can be formed in 2 ways RADAR is not a valid abbreviation

0

【数据规模】 1≤N≤100,每行字符串长度不超过150,询问不超过20,最后方案数不超过10^9

【分区联赛模拟试题2_2.单词缩写】

2017-04-15 21:09:09

1

64

N

1

1

0

1594

【分区联赛模拟试题2_3.求和】

高斯在他还是小P孩的时候就求出1 + 2 + … + n = n*(n+1)/2; LT在他还是小P孩的时候就求出1/(1*2) + … + 1/((n-1)*n) = 1-1/n; 现在,在你还是小P孩的时候,你要求出: <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1594.jpg>

输入两个整数nm。 【数据规模】 m>1,n>050%的数据满足n≤50100%的数据满足n+m≤500

输出占两行,第一行一个整数X,第二行一个整数Y,表示S=X/Y,且XY互质。

1 2

1 2

0

【数据规模】 m>1,n>050%的数据满足n≤50100%的数据满足n+m≤500

【分区联赛模拟试题2_3.求和】

2017-04-15 21:09:09

1

64

N

1

1

0

1595

【分区联赛模拟试题2_4.象棋比赛】

N个人要参加国际象棋比赛,该比赛要进行K场对弈。 每个人最多参加两场对弈,最少参加零场对弈。 每个人都有一个与其他人不相同的等级(用一个正整数来表示)。 在对弈中,等级高的人必须用黑色的棋子,等级低的人必须用白色的棋子。 每人最多只能用一次黑色的棋子和一次白色的棋子。 为了增加比赛的客观度,观众希望K场对弈中双方的等级差的总和最小。 比如有7个选手,他们的等级分别是30172641193818.,要进行3场比赛。 最好的安排是Player 2 vs Player 7Player 7 vs Player 5Player 6 vs Player 4,此时等级差的总和等于(18-17)+(19-18)+(41-38)=5达到最小。

第一行有两个正整数N,K; 接下来有N行,第i行表示第i+1个人的等级。

在第一行输出最小的等级差的总和。

7 3 30 17 26 41 19 38 18

5

0

【数据规模】 在90%的数据中,1≤N≤3000; 在100%的数据中,1≤N≤100000; 保证所有输入数据中等级的值小于10^81≤K≤N-1

【分区联赛模拟试题2_4.象棋比赛】

2017-04-15 21:09:09

1

64

N

2

2

0

1596

【分区联赛模拟试题3_1.天使的起誓】

TENSHI非常幸运的被选为掌管智慧之匙的天使。在正式任职之前,她必须和其他新当选的天使一样,要宣誓。 宣誓仪式是每位天使各自表述自己的使命,她们的发言稿被放在N个呈圆形排列的宝盒中。这些宝盒按顺时针方向被编上号码1、2、3……N-1N。一开始天使们站在编号为N的宝盒旁。 她们各自手上都有一个数字,代表她们自己的发言稿所在的盒子是从1号盒子开始按顺时针方向的第几个。例如:有7个盒子,那么如果TENSHI手上的数字为9,那么她的发言稿所在盒子就是第2个。 现在天使们开始按照自己手上的数字来找发言稿,先找到的就可以先发言。TENSHI一下子就找到了,于是她最先上台宣誓:我将带领大家开启NOI之门……”TENSHI宣誓结束以后,陆续有天使上台宣誓。可以有一位天使找了好久都找不到她的发言稿,原来她手上的数字M非常大,她转了好久都找不到她想找的宝盒。 任 务 :请帮助这位天使找到她想找的宝盒的编号。

输入文件有两行分别正整数NM,其中NM满足 2 ≤ N ≤ 10^82 ≤ M ≤ 10^1000

文件只有一行即宝盒的编号

样例1: 7 9 样例2: 11 108

样例1: 2 样例2: 9

0

 

【分区联赛模拟试题3_1.天使的起誓】

2017-04-15 21:09:09

1

64

N

0

1

0

1597

【分区联赛模拟试题3_2.步步高升】

春节的时候TENSHI去逛花市。她来到一个卖盆竹的摊位,看到一盆叫做步步高升的盆竹。步步高升,步步高升……”学习就是要一步一步来,不能急,要打好基础。在稳固的基础上才谈得上步步高升!TENSHI若有所思。她看到这盆东西好意头,于是想买下。谁知一问价钱,不贵不贵,才2XXRMB。”TENSHI差点没昏倒,囊中羞涩嘛。但是TENSHI还是很想买下来,于是她就在一旁观察。观察了一段时间,她发现这个卖盆竹的人和别人杀价很有规律。 设此人第i次报价为Wi元,那么他第i+1次报的价格为WiAWi B。 到了最后,TENSHIZ元成交,高高兴兴的回家去了。 任 务 :求TENSHI把盆竹的价格由W1元杀到Z元的方法总数。

输入文件第一行有两个正整数W1Z。 第二行有两个正整数AB。它们满足条件: 10 ≤ W1 ≤10^61 ≤ Z ≤ 10^6 Z < W1 2 ≤ A B ≤ 10000A≠B

将方法总数输出,只有一行。 注意:结果不超过MAXLONGINT

样例1: 256 88 5 9 样例2: 100 10 13 23

样例1: 3889832 样例2: 0

0

 

【分区联赛模拟试题3_2.步步高升】

2017-04-15 21:09:09

1

64

N

0

2

0

1598

【分区联赛模拟试题3_3.竞赛真理】

TENSHI在经历了无数次学科竞赛的失败以后,得到了一个真理:做一题就要对一题!但是要完全正确地做对一题是要花很多时间(包括调试时间),而竞赛的时间有限。所以开始做题之前最好先认真审题,估计一下每一题如果要完全正确地做出来所需要的时间,然后选择一些有把握的题目先做。 当然,如果做完了预先选择的题目之后还有时间,但是这些时间又不足以完全解决一道题目,应该把其他的题目用贪心之类的算法随便做做,争取一点分数。 任 务 :根据每一题解题时间的估计值,确定一种做题方案(即哪些题目认真做,哪些题目分,哪些不做),使能在限定的时间内获得最高的得分。

输入文件的第一行有两个正整数NT,表示题目的总数以及竞赛的时限(单位秒)。 以下的N行,每行4个正整数W1iT1iW2iT2i,分别表示第i题:完全正确做出来的得分,完全正确做出来所花费的时间(单位:秒),来的分数,分所花费的时间(单位秒)。 其中,3 ≤ N ≤ 302 ≤ T ≤ 30000 1 ≤ W1i W2i ≤ 10001 ≤ T1i T2i ≤ T

直接把所能得到的最高分值输出只有一行。

样例1 4 10800 18 3600 3 1800 22 4000 12 3000 28 6000 0 3000 32 8000 24 6000 样例2 3 7200 50 5400 10 900 50 7200 10 900 50 5400 10 900

样例1 50 样例2 70

0

 

【分区联赛模拟试题3_3.竞赛真理】

2017-04-15 21:09:09

1

64

N

0

0

0

1599

【分区联赛模拟试题3_4.标点符号】

有一天,TENSHI发现了一本叫《Road to NOI》的书。这本书是用英语写的,奇怪的是这本书完全没有标点符号,也没有空格!也就是说这本书整篇都是由一连串字母组成的。TENSHI研究了一会,发现了一种断句的方法: 1)单词是由字母组成的,并且都可以在《天使字典》(和《魔鬼字典》相对的)找到,且这些单词是不区分大小写的(也就是说TenShitenshi是一个单词) 2)每个单词的长度不超过10。 3)句子是由至少三个单词组成的,并且这些单词的字母总数是这些单词个数的倍数。 例如:iwanttoseeheragain 可以看成是这样一句话: I want to see her again. 因为单词数为6,且字母总数为18,18是6的倍数。 4)句子的第一个字母不一定要是大写字母。 5)每个句子的字母总数不超过50。 任 务 :给出一个字典以及一串字母,请为这串字母划分句子,使句子总数最多。

输入文件的第一行为一个正整数N3 ≤ N ≤ 100),表示《天使字典》的词汇总数。 紧跟着N行,每行有一个《天使字典》中的单词。 最后一行是一串待断句的字母串,字母串长度不大于255。输入文件没有多余空格。

把最多的句子总数输出到屏幕只有一行。

样例1 8 Again I Her See Tenshi To Want Zig IwaNttoseehEraGAin 样例2 12 A BC DEFG Hijk Lmno Pqrst Uv Wx Yz Tenshi XY MM Abcdefghijklmnopqrstuvwxyztenshixymm

样例1 1 样例2 3 (说明:断句方案为: A bc defg hijk lmno pqrst uv wx. Yz tenshi xy mm.

0

 

【分区联赛模拟试题3_4.标点符号】

2017-04-15 21:09:09

1

64

N

0

1

0

1600

【分区联赛模拟试题4_1.灰色头像】

引子: 你灰色头像不会再跳动 哪怕是一句简单的问候 心贴心的交流一页页翻阅多难过 是什么 坠落 升空 又想起你曾说的陪我到最后 暖色的梦变冰凉的枷锁 如果时光倒流我们又能抓得住什么。 背景: WJMZBMR喜欢上QQ。。但是很多人的头像已经变成灰色了。这让他压力很大。而且WJMZBMR的好友太多了,大量的灰色头像让他无法准确的找到他想找的好友。。 今天WJMZBMR决定清理一下他的QQ,找出那些不会在跳动的头像并且把它们踢掉。为此他翻出了最近一个月的聊天记录。 如果一个头像在在最近一个月中与WJMZBMR聊天次数小于等于2次,WJMZBMR就会认为这是不会再跳动的灰色头像然后把他删掉。 那么请你为WJMZBMR写个程序完成这件事情,并输出剩下的头像。 定义: 头像其实就是ID,是一个长度小于等于30的,由小写或者大写英文字母组成的字符串。 严格的数学定义: 给出一些字符串,输出其中出现次数大于等于3次的。 关于输出的顺序,出现次数多在前,如果次数一样多就按字典序,相同的ID只输出一次。

第一行N表示聊天记录的长度 接下来N行每行一个字符串表示与WJMZBMR聊天的ID

第一行表示要输出的头像的个数M 之后M行每行一个字符串表示输出的ID(请按给定顺序输出,两个相同的ID只输出一次)

6 Gx tracyhenry seventhplus Gx seventhplus Gx

1 Gx

0

数据范围: 20%的数据N<=1000 100%的数据 N<=100000 本次比赛满分400分。试题来源:陈立杰 感谢: NZK神犇帮我审题。 Ftiasch神犇帮我审题。 许嵩。 题目类型没有丝毫超纲(你看下去就知道了)。难度相当于 NOIP提高组。 250分以上应该一等奖稳了。 注: 所有题目内存限制为512MB,然后时间限制没有明说是每个测试点2s

【分区联赛模拟试题4_1.灰色头像】

2017-04-15 21:09:09

20

512

N

1

1

0

1601

【分区联赛模拟试题4_2.素颜】

引子: 如果再看你一眼 是否还会有感觉 最真实的喜怒哀乐全都埋葬在昨天 不掺任何的表演 轰轰烈烈那几年 我怀念 别怀念 怀念也回不到从前 背景: WJMZBMR已经长大了,不由感觉物是人非,又听起了许嵩的素颜,感到很伤感,想起很久以前自己玩过的一个游戏。不由感觉当年素面朝天要多纯洁就有多纯洁这个游戏是这样的,给你一个无穷大的棋盘,上面有一些黑棋子,WJMZBMR有无穷多的黑棋子。然后WJMZBMR如果看到三个黑棋子组成了一个两边平行于坐标轴的矩形的3个顶点,而第四个顶点上没有黑棋子,那么他就会在那个顶点上放一个黑棋子。一直到没有可以放的条件为止。 WJMZBMR想知道他能否无限放下去?如果不能,请输出棋盘上最后的棋子数量。 数学定义: P.S 下面这段话可能比较繁琐,因为要有数学定义就写了,如果你已经看懂就忽略数学定义这一块吧T_T。。。 三个棋子(x1,y1),(x2,y2),(x3,y3)如果满足 |{x1,x2,x3}|=2 |{y1,y2,y3}|=2 那么他们就是可以组成一个合法的平行与坐标轴矩形的3个顶点。 第四个顶点就可以放上一个棋子。

第一行N表示有N个黑棋子一开始就在棋盘上。 接下来N行,每行都表示一个棋子的坐标,其中X坐标在前,Y坐标在后。

一行,如果能无限放下去,输出-1 否则输出最后的棋子数(不保证范围)

3 0 0 0 1 1 0

4

0

数据范围: 对于40%的数据,N<=5000 对于100%的数据, N<=200000 xy都在longintPascal)和int(C++)的范围

【分区联赛模拟试题4_2.素颜】

2017-04-15 21:09:09

2

977

N

1

1

0

1602

【分区联赛模拟试题4_3.断桥残雪】

引子: 断桥是否下过雪 我望着湖面 水中寒月如雪 指尖轻点融解 断桥是否下过雪 又想起你的脸 若是无缘再见 白堤柳帘垂泪好几遍 背景: 在美丽的WJMZBMR的家乡,有很多的断桥,在冬天的时候,就会出现断桥残雪的景象。WJMZBMR不禁会哼起许嵩的《断桥残雪》。 但有时候这对交通也是一种阻碍T_T,在这里我们把位置看成节点,把连接位置之间的桥看成边。由于某些信春哥的原因,这些桥都是单向的囧。 但是由于雪大的原因,有些桥是会突然断掉的。由于WJMZBMR是信春哥的,桥不会在WJMZBMR走过的时候断掉,只会在WJMZBMR到它前面的时候突然断掉。而且春哥告诉WJMZBMR,只有一座桥由于有一次春哥在上面跑步承受了春哥的霸气有断掉的可能。 但春哥日理万机已经忘掉了是哪座桥了T_TWJMZBMR想从他的家去春哥那里膜拜!他的家是0号结点,春哥在1号。 WJMZBMR想知道在最坏的情况下,他最少需要多少时间能到到达春哥所在处。 数学定义: 这个是为了更加清楚的说明写的,如果您在上面已经看懂了就不用看了。如果您在上面没有看懂的话就别管上面的了。直接看数学模型吧。 这是一个二人博弈问题。假设是WJMZBMR在跟NZK神犇玩游戏。 给你一个带权有向图,每条边有一个经过的时间,有两个玩家WJMZBMRNZK神犇在玩游戏, WJMZBMR的目标是最快的从结点0到达结点1,他可以沿着一条边走到另一条边并花去一定的时间。 NZK神犇的目标是让WJMZBMR到达结点1的时间最长,NZK神犇的能力是在一个特定的时间让一条边断掉,但只能使用一次,并且不能在WJMZBMR在一条边上的时候使用。 求两者都是最优决策的情况下,WJMZBMR到达结点1的时间。

第一行四个数NM分别表示点数,边数 然后 M行,每行abc表示有一条从ab的长度为c的有向边。 结点编号从0N-1

一个数表示答案。

Sampe Input 1: 3 3 0 1 1 0 2 2 2 1 3 Sample Input 24 5 0 2 1 0 3 1 2 3 1 2 1 1 3 1 1

Sample Output 1: 5 Sample Output 2: 3 样例的解释: Sample 1 Explanation: WJMZBMR0号结点的时候,让0->1的桥断掉,WJMZBMR就只能走0->2->1的路径了,长度为5. Sample 2 Explanation: WJMZBMR一开始可以往2号结点和3号结点走,但是如果WJMZBMR3号结点走。那么如果3->1的桥被切断,WJMZBMR就无路可走悲剧了。 所以WJMZBMR只能一开始往2号结点走,然后2->1被切断(注意,这就是最坏情况,也是NZK神犇的决策),WJMZBMR就只能往2->3->1走了。总长度为3

0

数据范围: 40%的数据 N<=20 100%的数据 N<=300 M<=1000 一些解释: 这个题目是为了对应NOIP2009 trade出的图论题,因为本身的模型涉及二人博弈有点绕,本来不想出的,但由于此题的算法比较好,还是出了。我已经尽量将题目写清楚了,如果还是有不理解的,可以去答疑贴问,不过最好自己先看两遍,我怕被问爆囧T_T

分区联赛模拟试题4_3.断桥残雪】

2017-04-15 21:09:09

2

512

N

0

0

0

1603

【分区联赛模拟试题4_4.有何不可】

引子: 为你唱这首歌 没有什么风格 它仅仅代表着 我想给你快乐 为你解冻冰河 为你做一只扑火的飞蛾 没有什么事情是不值得 为你唱这首歌 没有什么风格 它仅仅代表着 我希望你快乐 为你辗转反侧 为你放弃世界有何不可 夏末秋凉里带一点温热 有换季的颜色 背景: 某天,WJMZBMR在外面闲逛,看到神牛XXX在跟他的GF(你们懂的)逛街。他的GF看中了N件物品,每件物品有价格和喜爱度,可WJMZBMR知道XXX不是神马富二代。 XXX身上一分钱都没有(全被他GF花光了)。XXX非常的痛苦的时候,被春哥看到了,春哥正好心情很好,看在XXX平时信春哥的份上,给了XXX M元钱。 同时那天是伟大的数学家Fibonacci的生日,所以所有商品的价格全部是Fibonacci数。 XXX很爱他的GF,他希望在自己能及的范围内让买来的物品的喜爱度最大。 WJMZBMR在旁边表示压力很大囧。。。 数学定义: Fibonacci数列:满足a[1]=1,a[2]=1,a[n]=a[n-1]+a[n-2]的数列。 前几项为1,1,2,3,5,8,13 Fibonacci数:Fibonacci数列中的数 N个物品,体积都是Fibonacci数,价值也给出,每个物品只有一个, 放入体积为M的背包中,求最大价值。 01背包问题的扩展

第一行NM表示物品数和钱数 接下来N行,每行两个数分别表示一个物品的价格和喜爱度

一行表示最大价值

3 10 1 3 5 8 8 10

13 样例的解释: 选择第一个和第三个物品

0

数据范围: 100%的数据 N<=200 40%的数据 M<=10000 100%的数据 M<=10^9 物品重量价值,可以用intlongint存储 注意: 虽然价值可以用int存储。但是价值的和说不定就要溢出了。

分区联赛模拟试题4_4.有何不可】

2017-04-15 21:09:09

2

512

N

0

0

0

1604

【分区联赛模拟试题5_1.中位数】

有一个长度为N的数列{A1A2……An},这N个数字恰好是1…N的一个排列。 你需要统计有多少个子序列{AiAi+1……Aj}满足:i<=jj-i+1为奇数,序列的中位数为B。 例如{513}的中位数为3

第一行包含两个正整数NB; 第二行包含N个整数,第i个整数为Ai

仅包含一个整数,为满足条件的子序列的个数。

7 4 5 7 2 4 3 1 6

4

0

对于30%的数据中,满足N<=100; 对于60%的数据中,满足N<=1000; 对于100%的数据中,满足N<=1000001<=B<=N

【分区联赛模拟试题5_1.中位数】

2017-04-15 21:09:09

1

128

N

0

0

0

1605

【分区联赛模拟试题5_2.敲砖块】

有一个凸槽中放置了N层砖块,最上面的一层有N块砖,从上到下每层依次减少一块砖。每块砖都有一个分值,敲掉这块砖就能得到相应的分值,如下图所示: <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1605.jpg> 如果你想敲掉第i层的第j块砖的话,若i=1,你可以直接敲掉它;若i>1,则你必须先敲掉第i-1层的第j和第j+1块砖。 你现在可以敲掉最多M块砖,求得分最多能有多少。

输入文件第一行有两个正整数NM; 接下来的N行,描述这N层砖块上的分值A[i,j],满足0<=A[i,j]<=100

仅一行,包含一个整数,为最大的得分。

4 5 2 2 3 4 8 2 7 2 3 49

19

0

对于20%的数据,满足1<=N<=101<=M<=30; 对于100%的数据,满足1<=N<=501<=M<=500

【分区联赛模拟试题5_2.敲砖块】

2017-04-15 21:09:09

1

128

N

0

0

0

1606

【分区联赛模拟试题5_3.单词】

N个单词和字符串T,按字典序输出字符串T为前缀的所有单词。

输入文件第一行包含一个正整数N; 接下来N行,每行一个单词,长度不超过20; 最后一行包含字符串T

按字典序长序输出答案。

6 na no ki ki ka ku k

ka ki ki ku

0

对于60%的数据,满足1<=N<=1000; 对于100%的数据,满足1<=N<=10000且所有字符均为小写字母。

【分区联赛模拟试题5_3.单词】

2017-04-15 21:09:09

1

128

N

2

2

0

1607

【分区联赛模拟试题5_4.邮递员送信】

有一个邮递员要送东西,邮局在结点1。他总共要送N-1样东西,其目的地分别是2…N。 由于这个城市的交通比较繁忙,因此所有的道路都是单行的,共有M条道路,通过每条道路需要一定的时间。这个邮递员每次只能带一样东西。 求送完这N-1样东西并且最终回到邮局最少需要多少时间。

输入文件第一行包含一个正整数NM; 接下来M行,每行三个正整数UVW,表示该条道路为从UV的,且通过这条道理需要W的时间。 满足1<=UV<=N1<=W<=10000,输入保证任意两点都能互相到达。

输出仅一行,包含一个整数,为最少需要的时间。

5 10 2 3 5 1 5 5 3 5 6 1 2 8 1 3 8 5 3 4 4 1 8 4 5 3 3 5 6 5 4 2

83

0

对于30%的数据,满足1<=N<=200; 对于100%的数据,满足1<=N<=10001<=M<=100000

【分区联赛模拟试题5_4.邮递员送信】

2017-04-15 21:09:09

1

128

N

0

0

0

1608

【分区联赛模拟试题6_1.7

1337个人排成一个圈,从1号人开始报数,初始的方向是1,2,3……。如果某个人报的数的7的倍数或者数字中含有7,那么报数的方向就反一下。问报数字的X的哪个人? 比如初始20个数字的情况是: 1:1 2:2 3:3 4:4 5:5 6:6 7:7 6:8 5:9 4:10 3:11 2:12 1:13 1337:14 1:15 2:16 3:17 2:18 1:19 1337:20

一行一个数,一个数X

一行一个数表示最终报数字X的是哪个人。

1000

1311

0

对于30%的数据中,满足X≤10^6 对于90%的数据中,满足X≤10^8 对于100%的数据中,满足X≤10^9

【分区联赛模拟试题6_1.7

2017-04-15 21:09:09

10

128

N

1

1

0

1609

【分区联赛模拟试题6_2.正方形计数】

给定平面上N个点,你需要计算以其中4个点位定点的正方形的个数。 注意这里的正方形边不一定需要和坐标轴平行。

第一行一个整数:N; 接下来,共N行,每行两个整数,空格隔开,用来表示N个点的坐标。

一个数,用来表示正方形的个数。

7 0 0 0 1 1 0 1 1 1 2 2 1 2 2

3

0

对于20%的数据,满足1≤N≤20; 对于100%的数据,满足1≤N≤500-50≤X[i]Y[i]≤50,点不会重叠。

【分区联赛模拟试题6_2.正方形计数】

2017-04-15 21:09:09

1

128

N

1

1

0

1610

【分区联赛模拟试题6_3.前缀单词】

一组单词是安全的,当且仅当不存在一个单词是另一个单词的前缀,这样才能保证数据不容易被误解。 现在你手上有一个单词集合S,你需要计算有多少个子集是安全的。 注意空集永远是安全的。

第一行一个数n,表示集合大小。 以下n行,每行一个由'a'..'z'构成的字符串。

安全子集的个数。

3 hello hell hi

6

0

对于30%的数据,满足1≤n≤10; 对于100%的数据,满足1≤n≤50;字符串长度≤50,没有两个字符串是完全相同的。

【分区联赛模拟试题6_3.前缀单词】

2017-04-15 21:09:09

1

128

N

1

1

0

1611

【分区联赛模拟试题6_4.数列】

给定一个长度是n的数列A,我们称一个数列是完美的,当且仅当对于其任意连续子序列的和都是正的。 现在你有一个操作可以改变数列,选择一个区间[X,Y]满足Ax+Ax+1+…+Ay0,1X≤Yn, 令S=Ax+Ax+1+…+Ay,对于Ax-1Ay+1分别加上SAxAy分别减去S(如果X=Y就减两次)。 问最少几次这样的操作使得最数列是完美的。

第一行一个数n,以下n个数。

一个数表示最少的操作次数,如果无解输出-1

5 13 -3 -4 -5 62

2 样例解释: 首先选择区间[2,4],之后数列变成19-4750,然后选择[33],数列变成154350

0

对于20%的数据,满足1≤N≤5; 对于100%的数据,满足1≤N≤10^51≤|A[i]|≤2^31-1

【分区联赛模拟试题6_4.数列】

2017-04-15 21:09:09

1

128

N

0

1

0

1612

【分区联赛模拟试题7_1.求和】

1^b+2^b+….+a^b 的和除以10000的余数。

第一行包含一个正整数N,表示共有N组测试数据; 接下来N行,每行包含两个正整数ab

N行,每行一个对应的答案。

1 2 3

9

0

对于30%的数据中,满足N≤10ab≤1000; 对于100%的数据中,满足N≤100ab≤10^9

【分区联赛模拟试题7_1.求和】

2017-04-15 21:09:09

1

128

N

0

0

0

1613

【分区联赛模拟试题7_2.序列合并】

有两个长度都为N的序列AB,在AB中各取一个数相加可以得到N^2个和; 求这个N^2个和中最小的N个。

第一行一个正整数N; 第二行N个整数Ai,满足Ai≤Ai+1Ai≤10^9; 第二行N个整数Bi,满足Bi≤Bi+1 Bi≤10^9

输出仅一行,包含N个整数; 从小到大输出这N个最小的和,相邻数字之间用空格隔开。

3 2 6 6 1 4 8

3 6 7

0

对于50%的数据,满足1≤N≤1000; 对于100%的数据,满足1≤N≤100000

【分区联赛模拟试题7_2.序列合并】

2017-04-15 21:09:09

1

128

N

0

0

0

1614

【分区联赛模拟试题7_3.Tower

平面上有N个整数坐标点。如果将点(x0y0)移动到(x1y1);则需要的代价为:x0-x1+y0-y1丨。 求使得KK=1,...N)个点在同一位置上最少需要的代价。

第一行一个正整数N; 接下来N,每行两个正整数XiYi,为第i个点的坐标,不超过10^6。 对于100%的数据,满足1≤N≤50

输出共N行; 第i行为使得有i个点在同一位置的最少代价。

4 15 14 15 16 14 15 16 15

0 2 3 4

0

对于100%的数据,满足1≤N≤50

【分区联赛模拟试题7_3.Tower

2017-04-15 21:09:09

1

128

N

0

0

0

1615

【分区联赛模拟试题7_4.二进制】

有三个整数A,B,C, 以下用N2) 表示N的二进制(没有前导零)。 设A2 B2 C2)的最大长度为L,你需要构造三个正整数X,Y,Z;满足以下条件: (1 X2),Y (2) , Z(2)的长度都不超过L; (2 A2)与X2)中1的个数相同。 (3 B2)与Y2)中1的个数相同。 (4 C2)与Z2)中1的个数相同 (5 X+Y=Z 你需要求出最小的满足条件的Z,如果不存在满足条件的Z,那么输出-1

第一行包含一个正整数T,表示有T组测试数据。 接下来T行,每行三个正整数A,B,C

输出共T行,每行一个答案;

4 7 6 9 1 1 1 1 1 4 3 3 9

10 -1 2 6

0

对于30%的数据,满足1≤A,B,C≤100; 对于100%的数据,满足1≤T≤10 1≤A,B,C<2^30

【分区联赛模拟试题7_4.二进制】

2017-04-15 21:09:09

1

128

N

0

0

0

1616

【分区联赛模拟试题8_1.序列】

有一个整数序列,它的每个数各不相同,我们不知道它的长度是多少(即整数个数),但我们知道在某些区间中至少有多少个整数。 用区间(LiRiCi)来描述,表示这个整数序列中至少有Ci个数来自区间[LiRi],给出若干个这样的区间,问这个整数序列的长度最少能为多少?

第一行一个整数N,表示区间个数; 接下来N行,每行三个整数(LiRiCi),描述一个区间。 数据规模: N≤10000≤Li≤Ri≤10001≤Ci≤Ri-Li+1

仅一个数,表示该整数序列的最小长度。

4 4 5 1 6 10 3 7 10 3 5 6 1

4

0

N≤10000≤Li≤Ri≤10001≤Ci≤Ri-Li+1

【分区联赛模拟试题8_1.序列】

2017-04-15 21:09:09

1

128

N

0

0

0

1617

【分区联赛模拟试题8_2.矩形】

给你个01矩阵,问共有多少个不同的全0矩阵?

第一行两个整数NM; 接下来N行,每行M个字符, 如果字符为‘.’,表示这格可行(即表示数字0); 如果为‘*’,表示不可行(即表示数字1)。

一个数表示答案。

6 4 . . . . . * * * . * . . . * * * . . . * . * * *

38

0

对于30%的数据,NM≤50; 对于100%的数据,NM≤200

【分区联赛模拟试题8_2.矩形】

2017-04-15 21:09:09

1

64

N

0

0

0

1618

【分区联赛模拟试题8_3.锁】

给出NK,要求生成从02^N-1的一个序列,序列的第一项为0,并且该序列满足以下三个条件: (1)序列长度为2^N,保证02^N-1每个数都用了且只用了一次。 (2)序列中任意两相邻的数都是由前一个数在其二进制下,改变了具有相同值的若干个位而形成的,即把其中若干个0变为1,或把其中若干个1变成0,并且只能二选一。 (3)当存在多个序列满足前两个条件的时候,要保证字典序最小,即由前一个数生成后一个数的时候,要挑值最小的数(当然是满足前两个条件的情况下)。 现问你这个序列前K项中的最大值是多少,输出其二进制形式,注意一定要输出N位,包括前导零。

仅一行两个整数NK

一个二进制表示的数,为所求的答案。

3 8

111 样例解释: 整个序列为“000”“001”“011”“010”“110”“100”“101”“111”

0

1≤N≤50 1≤K≤2^N,注意K可能超过longint

【分区联赛模拟试题8_3.锁】

2017-04-15 21:09:09

1

128

N

0

0

0

1619

【分区联赛模拟试题8_4.看守】

给出D维空间的N个点,求曼哈顿距离最大的两个点的曼哈顿距离。两个D维的点(X1X2Xd),(Y1Y2Yd)的曼哈顿距离定义为: <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1619.jpg >

第一行两上整数ND; 接下来N行,每行D个整数描述一个点的坐标。

输出最大的曼哈顿距离。

4 2 2 1 1 4 4 5 5 3

6

0

对于60%的数据,D≤2; 对于100%的数据,2≤N≤10^6D≤4

【分区联赛模拟试题8_4.看守】

2017-04-15 21:09:09

1

128

N

0

0

0

1620

【分区联赛模拟试题9_1.分组】

N组学生,给出初始时每组中的学生个数,再给出上界R和下界LL≤R); 每次你可以在某组中选出一个学生把他安排到另外一组中,问最少要操作多少次才可以使N组学生的人数都在[LR]中。

第一行一个整数N,表示学生组数; 第二行共N个整数,表示每组的学生人数; 第三行两个整数LR,表示下界和上界。

一个数表示最少的操作次数,如果不能满足题目条件输出–1

2 10 20 10 15

5

0

数据规模: N≤50L≤R,其他数都在[110^6]中。

【分区联赛模拟试题9_1.分组】

2017-04-15 21:09:09

1

64

N

0

0

0

1621

【分区联赛模拟试题9_2.阶乘】

给出N,求出N!最右边非零的数。

第一行一个整数T,表示数据组数; 接下来共T组: (每组一个整数,即:每行一个整数N。)

共输出T行,每行表示对应的答案。

1 5

2

0

数据规模: 对于30%的数据,N≤30T≤10; 对于100%的数据,N≤10^2009T≤30

【分区联赛模拟试题9_2.阶乘】

2017-04-15 21:09:09

1

64

N

0

0

0

1622

【分区联赛模拟试题9_3.拐弯】

N*N1≤N≤100)方格中,‘x’表示不能行走的格子,‘.’表示可以行走的格子。卡门很胖,故而不好转弯。 现在要从A点走到B点,请问最少要转90度弯几次?

第一行一个整数:N; 下面N行,每行N个字符: 只出现字符:‘.’ ‘x’ ‘A’ ‘B’ 表示上面所说的矩阵格子,每个字符后有一个空格。

一个整数:最少转弯次数。 如果不能到达,输出—1

3 . x A . . . B x .

2

0

数据范围:2≤N≤100; 注释: 只可以上、下、左、右四个方向行走,并且不能走出这些格子之外。开始和结束时的方向可以任意。

【分区联赛模拟试题9_3.拐弯】

2017-04-15 21:09:09

1

64

N

0

0

0

1623

【分区联赛模拟试题9_4.赛马】

我国历史上有个著名的故事: 那是在2300年以前,齐国的大将军田忌喜欢赛马,他经常和齐五赛马。他和齐王都有三匹马:常规马、上级马、超级马。一共赛三局,每局的胜者可以从负者这里取得200银币。每匹马只能用一次。齐王的马好,同等级的马,齐王的总是比田忌的要好一点。于是每次和齐王赛马,田忌总会输600银币。 田忌很沮丧,直到他遇到了著名的军师——孙膑。田忌采用了孙膑的计策之后,三场比赛下来,轻松而优雅地赢了齐王200银币。 这实在是个很简单的计策。由于齐王总是出最好的马,再出次好的,所以田忌用常规马对齐王的超级马,用自己的超级马对齐王的上级马,用自己的上级马对齐王的常规马,以两胜一负的战绩赢得200银币。实在很简单。 如果不止三匹马怎么办?这个问题很显然可以转化成一个二分图最佳匹配的问题。把田忌的马放左边,把齐王的马放右边。田忌的马A和齐王的马B之间,如果田忌的马胜,则连一条权为200的边;如果平局,则连一条权为0的边;如果输,则连一条权为-200的边……如果你不会求最佳匹配,用最小费用最大流也可以啊。 然而,赛马问题是一种特殊的二分图最佳匹配的问题,上面的算法过于先进了,简直是杀鸡用牛刀。现在,就请你设计一个简单的算法解决这个问题。

第一行一个整数N,表示他们各有N匹马(两人拥有的马的数目相同)。 第二行N个整数,每个整数都代表田忌的某匹马的速度值(0≤速度值≤100)。 第三行N个整数,描述齐王的马的速度值。两马相遇,根据速度的大小就可以知道哪匹马会胜出。如果速度相同,则和局,谁也不拿钱。

仅一行,一个整数,表示田忌最大能得到多少银币。

3 92 83 71 95 87 74

200

0

数据规模: 对于20%的数据,1≤N≤65; 对于40%的数据,1≤N≤250; 对于100%的数据,1≤N≤2000

【分区联赛模拟试题9_4.赛马】

2017-04-15 21:09:09

1

64

N

0

0

0

1624

【分区联赛模拟试题10_1.塔】

给出N个木块,告诉你每块木块的高度,你要用这些木块打出两座高度相同的塔,一座塔的高度为搭建它的木块的高度和,并且一座塔至少要用一个木块。木块只能用一次,也可以不用。 问在两座塔的高度相同的限制下,能够搭的塔的最大高度是多少?

第一行一个整数N,表示木块个数; 第二行N个整数,表示N块木块的高度。

一个数表示能搭建的最高的塔的高度,若不能搭建两座相同高度的塔,输出-1

3 2 3 5

5

0

数据规模: N≤50,每块木块的高度范围[1,500000],所有木块的高度总和≤500000.

【分区联赛模拟试题10_1.塔】

2017-04-15 21:09:09

1

64

N

0

0

0

1625

【分区联赛模拟试题10_2.圆】

给出N个圆,保证任意两个圆都是相离的,然后给出两个点(x1,y1,(x2,y2),保证所有点均不在边界上; 要从点(x1,y1)到(x2,y2)画条曲线,问这条曲线最少要穿过是多少次圆的边界?

第一行一个整数N,表示圆的个数; 第二行N个整数,表示N个圆的X坐标; 第三行N个整数,表示N个圆的Y坐标; 第四行N个整数,表示N个圆的半径R; 第五行四个整数x1y1x2y2

仅一个数。表示最少要穿过多少次圆的边界。

样例1 1 0 0 2 -5 1 5 1 样例2 7 1 -3 2 5 -4 12 12 1 -1 2 5 5 1 1 8 1 2 1 1 1 2 -5 1 12 1

样例1 0 样例2 3

0

数据规模: 1≤N≤50,坐标范围[-1000,1000],每个圆的半径1≤R≤1000。 保证没有两个圆有公共点,起点和终点不会落到某个圆的边界上。

【分区联赛模拟试题10_2.圆】

2017-04-15 21:09:09

1

64

N

0

0

0

1626

【分区联赛模拟试题10_3.猴子】

N只猴子,第一只尾巴挂在树上,剩下的N-1只,要么被其他的猴子抓住,要么抓住了其他的猴子,要么两者均有。 当然一只猴子最多抓两只另外的猴子,只有两只手嘛。 现在给出这N只猴子抓与被抓的信息,并且在某个时刻可能某只猴子会放掉它左手或右手的猴子,导致某些猴子落到地上。 求每只猴子落地的时间。

第一行两个数NM,表示有N只猴子,并且总时间为M-1; 接下来N行,描述了每只猴子的信息,每行两个数,分别表示这只猴子左手和右手抓的猴子的编号,如果是-1,表示该猴子那只手没抓其他的猴子。 再接下来M行,按时间顺序给出了一些猴子放手的信息,第1+N+i行表示第i-1时刻某只猴子的放手信息,信息以两个数给出: (前者表示放手的猴子编号,后者表示其放的是哪只手,1左、2右。)

共输出N行; 第i行表示第i只猴子掉落的时刻,若第i只猴子到M-1时刻以后还没掉落,就输出-1

3 2 -1 3 3 -1 1 2 1 2 3 1

-1 1 1

0

数据规模: 30%的数据,N≤1000M≤1000 100%的数据,1≤N≤200000,1≤M≤400000

【分区联赛模拟试题10_3.猴子】

2017-04-15 21:09:09

1

64

N

0

0

0

1627

【分区联赛模拟试题10_4.山】

给出一座山,如下图所示: <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1627.jpg > 现在要在山上的某个部位装一盏灯,使得这座山的任何一个部位都能够被看到。 给出最小的y坐标,如图的+号处就是y坐标最小的安装灯的地方。

第一行一个数N,表示这座山由N个点构成; 接下来N行从左到右给出了这座山的构造情况,每行两个数XiYi,表示一个折点,保证Xi>Xi-11<i≤N)。

仅输出一行,为最小的y坐标,当你的答案与标准答案相差不超过0.01时,则被认为是正确的。

6 0 0 10 0 11 1 15 1 16 0 25 0

3.00

0

数据规模: 30%的数据,1≤N≤50 100%的数据,1≤N≤50000≤XiYi≤100000,保证答案不超过1000000.

【分区联赛模拟试题10_4.山】

2017-04-15 21:09:09

1

64

N

0

0

0

1628

【分区联赛模拟试题11_1.产品排序】

有一系列产品,给定每个产品的加工时间和冷却成型时间(冷却过程产品之间没有关系,是单独冷却的)。 现在你手上有两台机器可以用来加工,你需要安排产品的加工顺序以及去哪台机器加工,使得所有产品都成型的时间最早。 机器之间互不相关,可以同时进行工作,一个机器一个时刻只能加工一个产品。

第一行一个数n,表示产品个数; 以下n行,每行两个数:分别表示产品的加工时间A[i]和冷却时间B[i]

输出一个数,表示所有产品成型的最早时间。

3 1 4 3 3 4 1

6

0

对于20%的数据,满足n≤6; 对于100%的数据,满足nA[i]B[i]≤200

【分区联赛模拟试题11_1.产品排序】

2017-04-15 21:09:09

1

64

N

1

1

0

1629

【分区联赛模拟试题11_2.分球】

N个标号的球分到M个无差别的盒子里,每个盒子至少有一个球,问总共有多少种方案数。

输入文件包含多组数据。 每组数据,一行两个整数:NM

每组数据对应输出一行,一个整数,表示该方案数。

4 2 1 1

7 1 样例解释: N=4M=2 1 2 3 4 2 1 3 4 3 1 2 4 4 1 2 3 1 2 3 4 1 3 2 4 1 4 2 3

0

对于20%的数据,满足1≤NM≤10 对于100%的数据,满足1≤NM≤100,数据组数≤10

【分区联赛模拟试题11_2.分球】

2017-04-15 21:09:09

1

64

N

0

0

0

1630

【分区联赛模拟试题11_3.地图】

给定一张地图,定义X表示陆地,O表示海洋。两个格子连通的当且仅当他们共边。 一个大陆定义是一个极大的陆地连通块。 极大的连通块的定义:不存在一个格子与当前连通块中中的某个格子相连但不属于当前连同块。 问地图中有几个大陆。

第一行共两个整数:NM,表示地图的大小; 接下来共N行,每行M个字母,用来描述地图。

输出一个整数:表示大陆个数。

5 5 XXXOO OOXOO OOOXX XOOOO XOXXX

4

0

对于30%的数据,满足1≤NM≤50; 对于100%的数据,满足1≤NM≤1000.

【分区联赛模拟试题11_3.地图】

2017-04-15 21:09:09

1

64

N

1

1

0

1631

【分区联赛模拟试题11_4.坐标变换】

给定平面上N个点,求一个凸包,使得凸包的顶点含给定的点最多,凸包边上不能含有给定点,且原点必须在凸包边上。

第一行一个整数N; 接下来共N行,用来表示N个点; 每行两个整数:表示当前点坐标(X[i]Y[i]

输出一个整数:表示凸包上最多能包含的点数(包括原点)

5 4 2 2 2 2 3 3 2 3 1

4

0

对于30%的数据,满足1≤N≤15; 对于100%的数据,满足1≤N≤1001≤X[i]Y[i]≤100

【分区联赛模拟试题11_4.坐标变换】

2017-04-15 21:09:09

1

64

N

0

0

0

1632

【分区联赛模拟试题12_1.购物】

你就要去购物了,现在你手上有N种不同面值的硬币,每种硬币有无限多个。 为了方便购物,你希望带尽量少的硬币,但要能组合出1X之间的任意值。

每一行两个数XN,以下N个数,表示每种硬币的面值。

最少需要携带的硬币个数,如果无解输出 —1

20 4 1 2 5 10

5

0

数据规模: 对于30%的数据,满足 N≤3X≤20; 对于100%的数据,满足N≤10X≤1000

【分区联赛模拟试题12_1.购物】

2017-04-15 21:09:09

1

64

N

0

0

0

1633

【分区联赛模拟试题12_2.养猪】

你有一个猪圈,有N头猪,每天你最多可以杀一头猪卖钱,获益就是猪的体重。 但是每过一天每头猪的体重都会下降P[i](当然,如果猪体重≤0了,自然获利就是0),问K天你的最大获利。

第一行两个数NK; 第二行N个数表示猪的初始重量A[i]; 第三行N个数表示P[i]

一行一个数表示最大获利。

2 2 10 10 1 2

19

0

数据规模: 对于20%的数据,满足 1≤N≤20; 对于100%的数据,满足1≤N≤1000,初始重量≤100000

【分区联赛模拟试题12_2.养猪】

2017-04-15 21:09:09

1

64

N

0

0

0

1634

【分区联赛模拟试题12_3.数位平方和】

定义Sn)表示n的各个数位的k次方的和。 定义Hn=minnSn),HSn))} 求:<img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1634.jpg >

一行三个数KAB

一个数 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1634.jpg >

2 1 5

14

0

数据规模: 对于20%的数据,满足 1≤AB≤50; 对于100%的数据,满足1≤AB≤10^6K≤6

【分区联赛模拟试题12_3.数位平方和】

2017-04-15 21:09:09

1

64

N

0

0

0

1635

【分区联赛模拟试题12_4.扩散】

一个点每过一个单位时间就会向4个方向扩散一个距离,如下图所示: <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1635.jpg > 两个点ab连通,记作eab),当且仅当ab的扩散区域有公共部分。连通块的定义是块内的任意两个点uv都必定存在路径eua0),ea0a1),……eakv)。 给定平面上的n个点,问最早什么时刻它们形成一个连通块。

第一行一个数n,以下n行,每行一个点坐标。

一个数,表示最早的时刻所有点形成连通块。

2 0 0 5 5

5

0

数据规模: 对于20%的数据,满足 1≤N≤5;1≤X[i]Y[i] ≤50; 对于100%的数据,满足1≤N≤50;1≤X[i]Y[i] ≤10^9

【分区联赛模拟试题12_4.扩散】

2017-04-15 21:09:09

1

64

N

0

0

0

1636

【分区联赛Day1_1.混乱的队伍】

LongDD  N4 <=N<=16 )个员工每人都有一个唯的编号 S_i(1 <= S_i <= 25,000)。员工们为他们的编号感到骄傲,所以每个人都把他的编号刻在一个金牌上, 并且把金牌挂在他们的脖子上。 员工 们对在 吃饭 的时候被排成一支混乱的队伍非常反感。 如果一个队伍里任意两相邻的人的编号相差超过 K 1 <= K <= 3400),它就被称为是混乱的。 比如说, 当 N=6, K=1 ,1, 3, 5, 2, 6, 4 就是一支 就是一支混乱的队伍 , 但是1, 3, 6, 5, 2, 4 不是 (因为 5 6只相差 1)。那么,有多少种能够使员工们排成混乱的队伍方案呢?

 1 : 用空格隔开的两个整数 N K  2..N+1 :  i+1 行包含了一个用来表示第 i个员工 的编号整数 S_i

 1 : 只有一个整数 , 表示有多少种能够使员工们排成混乱的队伍方案。 (答案保证是一个在 64 位范围内的整数。)

4 1 3 4 2 1

2

0

【输出解释 】 两种方法分别是 : 3 1 4 2 2 4 1 3

【分区联赛Day1_1.混乱的队伍】

2017-04-15 21:09:09

1

64

N

0

0

0

1637

【分区联赛Day1_1.安慰员工】

LongDD 变得非常懒,他不想再继续维护供员工之间供通行的道路。 道路被用来连接 N(5 <= N <= 10,000) 个房子,房子被连续地编号为 1..N ,每一个房子 都是一个员工的家。 LongDD 计划除去 PN-1 <=P<= 100000)条道路中尽可能多的, 但是还要保持房子之间的连通性。你首先要决定那些道路是需保留的 N-1条道路。 第j条双向道路连接了房子S_jE_j (1 <= S_j <= N 1 <= E_j <= N S_j != E_j),而且走完它需要L_j (0 <= L_j <= 1,000)的时间.没有两个房子是被一条以上的道路所连接. 员工们非常伤心, 因为她们的交通系统被削减了. 你需要到每一个员工的住处去安慰她们. 每次你到达第i个房子的时候(即使你已经到过), 你必须花去C_i (1 <= C_i <= 1,000)的时间和员工交谈. 你需要从某一个房子出发(这是供你选择的),并最终回到这个房子。期间,你要经过每个房子至少一次,并且当你经过某个房子的时候,你必须和这个房子里的员工交谈(即使你已经到过). 假设LongDD采纳了你的建议, 请计算出使所有员工都被安慰的最少时间。

1 : 用空格隔开的两个整数NP 2..N+1 : i+1行包含了一个整数: C_i N+2..N+P+1 : N+j+1 行包含用空格隔开的三个整数: S_j, E_j L_j 【输入解释】 +-(15)-+ / \ / \ 1-(5)-2-(5)-3-(6)--5 \/ / (12)\/(17)/(12) 4------+

 

5 7 10 10 20 6 30 1 2 5 2 3 5 2 4 12 3 417 2 5 15 3 5 6 4 5 12

 

0

 

 

2017-04-15 21:09:09

1

64

N

0

0

0

1638

NOI导刊2010模拟试题.新的开始】

故事背景: 话说小FF在经历了上次寻找古代王族遗产的探险后,成为了世界上最伟大的探险家并拥有了一大笔财富。 当然他不能坐吃山空,必须创造财富!! 于是他买下了传说中的Greed Island并优先发展那里的采矿业……他还将其称为Greed Island“NewBe_One”计划。 试题一: 新的开始 【题目描述】 发展采矿业当然首先得有矿井, 小FF花了上次探险获得的千分之一的财富请人在岛上挖了n口矿井, 但他似乎忘记考虑的矿井供电问题…… 为了保证电力的供应, 小FF想到了两种办法: 1、 在这一口矿井上建立一个发电站, 费用为v(发电站的输出功率可以供给任意多个矿井)。 2、 将这口矿井与另外的已经有电力供应的矿井之间建立电网, 费用为p。 小FF希望身为”NewBe_One" 计划首席工程师的你帮他想出一个保证所有矿井电力供应的最小花费。

第一行一个整数n, 表示矿井总数。 第2n+1行,每行一个整数, 第i个数v[i]表示在第i口矿井上建立发电站的费用。 接下来为一个n*n的矩阵P, 其中p[ i , j ]表示在第i口矿井和第j口矿井之间建立电网的费用(数据保证有p[ i, j ] = p[ j, i ],  p[ i, i ]=0)。

仅一个整数, 表示让所有矿井获得充足电能的最小花费。

4 5 4 4 3 0 2 2 2 2 0 3 3 2 3 0 4 2 3 4 0

9 输出样例说明: 小FF可以选择在4号矿井建立发电站然后把所有矿井都与其建立电网,总花费是 3+2+2+2 = 9

0

【数据范围】 对于30%的数据: 1<=n<=50; 对于100%的数据: 1<=n<=300; 0<=v[i], p[i,j] <=10^5.

NOI导刊2010模拟试题.新的开始】

2017-04-15 21:09:09

10

64

N

0

2

0

1639

NOI导刊2010模拟试题.工业时代】

【试题描述】 小FF的第一片矿区已经开始运作了, 他着手开展第二片矿区…… FF的第二片矿区, 也是”NewBe_One“计划的核心部分, 因为在这片矿区里面有全宇宙最稀有的两种矿物,科学家称其为NEW矿和BE矿。 矿区是被划分成一个n*m的矩形区域。 小FF探明了每一小块区域里的NEW矿和BE矿的蕴藏量, 并且小FF还在矿区的北边和西边分别设置了NEW矿和BE矿的收集站。你的任务是设计一个管道运输系统,使得运送的NEW矿和BE矿的总量最多。 管道的型号有两种,一种是东西向,一种是南北向。在一个格子内你能建造一种管道,但不能两种都建。如果两个同类型管道首位相接,它们就可以被连接起来。 另外这些矿物都十分不稳定,因此它们在运送过程中都不能拐弯。这就意味着如果某个格子上建有南北向管道,但是它北边的格子建有东西向管道,那么这根南北向管道内运送的任何东西都将丢失。进一步地,运到NEW矿收集站的BE矿也会丢失,运到BE矿收集站的NEW矿也会丢失。 <img border=0 src=http://127.0.0.1:80/JudgeOnline/images/P1639.jpg>

第一行包含两个整数nm,表示矿区大小。 以下n行,每行m个整数,其中第i行第j个整数G[ i , j ] 描述各个格子上的BE矿数量。接下来以类似的矩阵表示各个格子上的NEW矿数量。

仅一个整数, 表示最多可以采集到的NEW矿和BE矿的总量。

4 4 0 0 10 9 1 3 10 0 4 2 1 3 1 1 20 0 10 0 0 0 1 1 1 30 0 0 5 5 5 10 10 10

98

0

【数据范围】 对于30%的数据: 0<= nm <=100; 对于100%的数据: 0<= n, m <=1000; 0<= G[ i, j ] <=1000.

NOI导刊2010模拟试题.工业时代】

2017-04-15 21:09:09

10

64

N

0

0

0

1640

NOI导刊2010模拟试题.杀蚂蚁】

【题目描述】 说善有善报,恶有恶报,不是不报……”。 小FF一心只顾自己企业的壮大而没顾及自己的采矿业对Greed Island上生态环境的破坏, Greed Island的环境日益恶劣。 终于,岛上的蚂蚁们变异了,它们决定对小FF的矿区进行攻击,欲将岛上的人类驱逐出去……面对蚂蚁们的进攻, 人类节节败退。无奈之下, 小FF请来了全宇宙最强的防御系统制造商派来的工程机器人——SCV,希望能够阻挡蚂蚁的攻势。 经过小FF的研究,他发现蚂蚁们每次都走同一条长度为n个单位的路线进攻, 且蚂蚁们的经过一个单位长度所需的时间为T秒。也就是说,只要小FF在条路线上布防且给蚂蚁造成沉痛伤害就能阻止蚂蚁的进军。 SCV擅长制造的防御塔有三种,分别是激光塔,放射塔和干扰塔, 他们可以在一个单位长度内修建一座防御塔。三种防御塔的作用如下: 激光塔: 使用高能激光,当蚂蚁从塔前经过时每秒对蚂蚁造成r点伤害。 放射塔: 释放放射性元素, 当蚂蚁经过这座塔后,每一秒受到g点伤害。 干扰塔: 干扰塔负责干扰蚂蚁们的信息素,使得蚂蚁在经过这座塔后,经过之后每一个单位长度的时间变成T+b。 当然, 放射塔和干扰塔的效果是可以叠加的, 也就是说如果敌人经过x座放射塔,那么敌人每秒钟会受到x*g点伤害; 同理,如果敌人经过y座干扰塔, 那么敌人经过一个单位长度的时间将变为T+y*b。 现在距离蚂蚁的下一轮进攻还有足够长的时间,你这个“NewBe_One”计划的首席工程师现在被任命为战略总参谋长, 因此你必须设计一个给蚂蚁们造成最大伤害的布塔方案。

输入数据仅一行, 5个整数 n, r, g, b, T中间用一个空格隔开。 它们分别表示你可以布防的总长度, 激光塔的效果、 放射塔的效果和干扰塔的效果。

输出仅一个整数, 代表你的方案给敌人带来的最大伤害值。

5 4 3 2 1

82 输出样例解释: 第1号位置为放射塔, 第23号位置建造干扰塔,第45号位置建造激光塔。

0

【数据范围】 对于30%的数据: 1<=n<=20; 对于60%的数据: 1<=n<=1024; 0<=r, g, b<=65536; 0<=T<=3; 对于另外40%的数据: 1<=n<=400; 0<=r, g, b<=2^31-1; 0<=t<=1000.

NOI导刊2010模拟试题.杀蚂蚁】

2017-04-15 21:09:09

10

64

N

0

0

0

1641

NOI导刊2010模拟试题.贪婪大陆】

【题目描述】 面对蚂蚁们的疯狂进攻,小FFTower defence宣告失败……人类被蚂蚁们逼到了Greed Island上的一个海湾。现在,小FF的后方是一望无际的大海, 前方是变异了的超级蚂蚁。 小FF还有大好前程,他可不想命丧于此, 于是他派遣手下最后一批改造SCV布置地雷以阻挡蚂蚁们的进攻。 小FF最后一道防线是一条长度为N的战壕, 小FF拥有无数多种地雷,而SCV每次可以在[ L , R ]区间埋放同一种不同于之前已经埋放的地雷。 由于情况已经十万火急,小FF在某些时候可能会询问你在[ L' , R'] 区间内有多少种不同的地雷, 他希望你能尽快的给予答复。

第一行为两个整数nm n表示防线长度, m表示SCV布雷次数及小FF询问的次数总和。 接下来有m行, 每行三个整数QL , R; 若Q=1 则表示SCV[ L , R ]这段区间布上一种地雷, 若Q=2则表示小FF询问当前[ L , R ]区间总共有多少种地雷。

对于小FF的每次询问,输出一个答案(单独一行),表示当前区间地雷总数。

5 4 1 1 3 2 2 5 1 2 4 2 3 5

1 2

0

【数据范围】 对于30%的数据: 0<=n, m<=1000; 对于100%的数据: 0<=n, m<=10^5.

NOI导刊2010模拟试题.贪婪大陆】

2017-04-15 21:09:09

10

64

N

0

1

0

1642

2013高一开学排位赛1.未免太简单】

Problem 1 未免太简单(easy.cpp/c/pas) 题目描述   Lemon手上有一个长度为n的数列,第i个数为xi。   他现在想知道,对于给定的a,b,c,他要找到一个i,使得a*(i+1)*xi^2+(b+1)*i*xi+(c+i)=0成立。如果有多个i满足,Lemon想要最小的那个i。   Lemon有很多很多组询问需要你回答,多到他自己也不确定有多少组。所以在输入数据中a=b=c=0标志着Lemon的提问的结束。   更加糟糕的是,Lemon为了加大难度,决定对数据进行加密以防止离线算法的出现。   假设你在输入文件中读到的三个数为a0,b0,c0,那么Lemon真正要询问的a=a0+lastans,b=b0+lastans,c=c0+lastans.   lastans的值是你对Lemon的前一个询问的回答。如果这是第一个询问,那么lastans=0 所有的询问都将会按上述方式进行加密,包括标志着询问的结束的那个询问也是这样。

输入格式(easy.in)   输入文件第一行包含一个正整数n,表示数列的长度。   输入文件第二行包含n个整数,第i个数表示xi的值。   接下来若干行,每行三个数,表示加密后的a,b,c值(也就是上文所述的a0,b0,c0

输出格式(easy.out)   包含若干行,第i行的值是输入文件中第i个询问的答案。注意,你不需要对标志着询问结束的那个询问作答。   同时,标志着询问结束的询问一定是输入文件的最后一行。也就是,输入文件不会有多余的内容。

样例输入   5   -2 3 1 -5 2   -5 -4 145   -1 -6 -509   -9 -14 40   -3 -13 21   -3 -3 -3

样例输出   5   4   3   3

0

样例解释   第一个询问中,真实的a=-5+0=-5b=-4+0=-4c=145+0=145(第一个询问中lastans=0)   带入发现,i=5时,-5*(5+1)*2^2+(-4+1)*5*2+145+5=0,而其他的i均不符合条件。所以答案是5.   第二个询问中,真实的a=-1+5=4,b=-6+5=-1,c=-509+5=-504lastans是上一个询问的答案的值,也就是5)   经带入发现,i=4时,4*(4+1)*(-5)^2+(-1+1)*4*(-5)+(-504)+4=0,满足条件,而其他的i均不满足条件,所以答案是4.   同理,第三个询问中真实的a=-5,b=-10,c=44.答案i=3   第四个询问中真实的a=0,b=-10,c=24,答案i=3   第五个询问中真实的a=0,b=0,c=0,此时我们发现这是一个标志着结束的询问,这个询问我们无需作出回答。 数据范围   对于前4组数据,每组10分,满足N<=1000,需要作出回答的询问个数不超过1000.   对于后2组数据,每组30分满足N<=50000,需要作出回答的询问个数不超过500000xi的绝对值不超过30000,解密后的a的绝对值不超过50000,解密后的b的绝对值不超过10^8,解密后的c的绝对值不超过10^18.

2013高一开学排位赛1.未免太简单】

2017-04-15 21:09:09

300

6400

N

0

1

0

1643

2013高一开学排位赛2.Lights Out

Problem 2 Lights Out(light.cpp/c/pas) 题目描述 Lenny is playing a game on a 3 × 3 grid of lights. In the beginning of the game all lights are switched on. Pressing any of the lights will toggle it and all side-adjacent lights. The goal of the game is to switch all the lights off. We consider the toggling as follows: if the light was switched on then it will be switched off, if it was switched off then it will be switched on. Lenny has spent some time playing with the grid and by now he has pressed each light a certain number of times. Given the number of times each light is pressed, you have to print the current state of each light.

输入格式(light.in) The input consists of three rows. Each row contains three integers each between 0 to 100 inclusive. The j-th number in the i-th row is the number of times the j-th light of the i-th row of the grid is pressed.

输出格式(light.out) Print three lines, each containing three characters. The j-th character of the i-th line is "1" if and only if the corresponding light is switched on, otherwise it's "0".

输入样例 1 0 0 0 0 0 0 0 1

输出样例 001 010 100

0

 

2013高一开学排位赛2.Lights Out

2017-04-15 21:09:09

1

64

N

0

2

0

1644

2013高一开学排位赛3.射命丸文】

Problem 3 射命丸文(aya.cpp/c/pas) 题目描述   在幻想乡,射命丸文是以偷拍闻名的鸦天狗。当然,文文的照相机可不止能够照相,还能够消除取景框里面所有的弹幕。假设现在文文面前有一块NM列的弹幕群,每一个单位面积内有分值有num[i][j]的弹幕。相机的取景框可以将一块RC列的弹幕消除,并且得到这一块区域内所有弹幕的分值(累加)。现在文文想要取得尽可能多的分值,请你计算出她最多能够得到的分值。

输入格式(aya.in) 1行:4个正整数N,M,R,C   第2..N+1行:每行M个正整数,第i+1行第j个数表示num[i][j]

输出格式(aya.out)   第1行:1个整数,表示文文能够取得的最大得分

输入样例 3 5 2 3 5 2 7 1 1 5 9 5 1 5   3 5 1 5 3

输出样例   33

0

数据范围 对于60%的数据:1 <= N,M <= 200 对于100%的数据:1 <= N,M <= 1,000 1 <= R <= N, 1 <= C <= M 1 <= num[i][j] <= 1000 保证结果不超过2,000,000,000

2013高一开学排位赛3.射命丸文】

2017-04-15 21:09:09

3

64

N

0

2

0

1645

【高精度】a/b(计算有效位小数点)

两个数相除,小数点后的有效位数为1000位!

读入两个整数ab,请计算出a/b的结果 10/3

3.(3)

10/3

3.(3)

0

 

【高精度】a/b(计算有效位小数点)

2017-04-16 09:13:09

1

64

N

3

3

0

1646

良辰最喜欢对那些自认能力出众的人出手(感谢cqupt..

<p style="color:#333333;font-family:source_code_pro, PingFangSC-Regular, "font-size:15px;background-color:#FFFFFF;"> 果果一直很谦虚,但是良辰还是对他出手了(汗。。<br /> <br /> 良辰拿出来一个 Pascal 三角形(也叫杨辉三角形。(请不要问是怎么拿出来的。。<br /> <br /> 我们用一个矩阵来表示 Pascal 三角形<br /> <br /> 0: C(0, 0)<br /> <br /> 1: C(1, 0) C(1, 1)<br /> <br /> 2: C(2, 0) C(2, 1) C(2, 2)<br /> <br /> ...<br /> <br /> 其中最左边的数字表示行号。C(x, y) 表示一个组合数,即 x 个元素中取 y 个的方法数。<br /> <br /> 良辰只有一个问题:Pascal 三角形中的第 n 行有多少个奇数?<br /> <br /> 这样的问题对于果果来说太水了,于是他把这个问题给了你。<br /> </p>

第一行为一个整数 T,表示数据组数。<br /> 每组数据只有一行,包含一个整数 n,表示 Pascal 三角形的第 n 行。<br /> T <= 2000,0 <= n <= 2^31<br />

每组数据输出一行,包含一个整数,表示Pascal 三角形的第 n 行中的奇数个数。

2 0 1

1 2

0

 

重庆邮电大学2015校赛;QDU_15_11_08月赛

2017-04-16 09:20:27

1

128

N

1

2

0

1647

【高精度】Exponentiation

Problems involving the computation of exact values of very large magnitude and precision are common. For example, the computation of the national debt is a taxing experience for many computer systems. This problem requires that you write a program to compute the exact value of Rn where R is a real number ( 0.0 < R < 99.999 ) and n is an integer such that 0 < n <= 25.

The input will consist of a set of pairs of values for R and n. The R value will occupy columns 1 through 6, and the n value will be in columns 8 and 9.

The output will consist of one line for each line of input giving the exact value of R^n. Leading zeros should be suppressed in the output. Insignificant trailing zeros must not be printed. Don't print the decimal point if the result is an integer.

95.123 12 0.4321 20 5.1234 15 6.7592 9 98.999 10 1.0100 12

548815620517731830194541.899025343415715973535967221869852721 .00000005148554641076956121994511276767154838481760200726351203835429763013462401 43992025569.928573701266488041146654993318703707511666295476720493953024 29448126.764121021618164430206909037173276672 90429072743629540498.107596019456651774561044010001 1.126825030131969720661201

0

If you don't know how to determine wheather encounted the end of input: s is a string and n is an integer C++ while(cin>>s>>n) { ... } c while(scanf("%s%d",s,&n)==2) //to see if the scanf read in as many items as you want /*while(scanf(%s%d",s,&n)!=EOF) //this also work */ { ... }

http://poj.org/problem?id=1001

2017-04-16 09:21:56

1

64

N

0

2

0

1648

【高精度】Round and Round We Go

A cyclic number is an integer n digits in length which, when multiplied by any integer from 1 to n, yields a"cycle"of the digits of the original number. That is, if you consider the number after the last digit to "wrap around"back to the first digit, the sequence of digits in both numbers will be the same, though they may start at different positions.For example, the number 142857 is cyclic, as illustrated by the following table: 142857 *1 = 142857 142857 *2 = 285714 142857 *3 = 428571 142857 *4 = 571428 142857 *5 = 714285 142857 *6 = 857142

Write a program which will determine whether or not numbers are cyclic. The input file is a list of integers from 2 to 60 digits in length. (Note that preceding zeros should not be removed, they are considered part of the number and count in determining n. Thus, "01"is a two-digit number, distinct from "1" which is a one-digit number.)

For each input integer, write a line in the output indicating whether or not it is cyclic.

142857 142856 142858 01 0588235294117647

142857 is cyclic 142856 is not cyclic 142858 is not cyclic 01 is not cyclic 0588235294117647 is cyclic

0

Greater New York 2001 北京大学POJhttp://poj.org/ 13、任意精度运算、数字游戏、高精度计算 关于本模块题型: 1001 1023 1047 1060 1079 1131 1140 1142 1207 1220 1284 1289 1306 1316 1338 1405 1454 1503 1504 1519 1565 1650 1969 2000 2006 2081 2247 2262 2305 2316 2389 1001, 1220, 1405, 1503,1001(高精度乘法) 2413(高精度加法,还有二分查找)

http://poj.org/problem?id=1047

2017-04-16 09:21:56

1

64

N

0

2

0

1649

【高精度】Octal Fractions

Fractions in octal (base 8) notation can be expressed exactly in decimal notation. For example, 0.75 in octal is 0.953125 (7/8 + 5/64) in decimal. All octal numbers of n digits to the right of the octal point can be expressed in no more than 3n decimal digits to the right of the decimal point. Write a program to convert octal numerals between 0 and 1, inclusive, into equivalent decimal numerals.

The input to your program will consist of octal numbers, one per line, to be converted. Each input number has the form 0.d1d2d3 ... dk, where the di are octal digits (0..7). There is no limit on k.

Your output will consist of a sequence of lines of the form 0.d1d2d3 ... dk [8] = 0.D1D2D3 ... Dm [10] where the left side is the input (in octal), and the right hand side the decimal (base 10) equivalent. There must be no trailing zeros, i.e. Dm is not equal to 0.

0.75 0.0001 0.01234567

0.75 [8] = 0.953125 [10] 0.0001 [8] = 0.000244140625 [10] 0.01234567 [8] = 0.020408093929290771484375 [10]

0

Southern African 2001

http://poj.org/problem?id=1131

2017-04-16 09:21:56

1

64

N

0

2

0

1650

【高精度】Integer Inquiry

One of the first users of BIT's new supercomputer was Chip Diller. He extended his exploration of powers of 3 to go from 0 to 333 and he explored taking various sums of those numbers. ``This supercomputer is great,'' remarked Chip. ``I only wish Timothy were here to see these results.'' (Chip moved to a new apartment, once one became available on the third floor of the Lemon Sky apartments on Third Street.)

The input will consist of at most 100 lines of text, each of which contains a single VeryLongInteger. Each VeryLongInteger will be 100 or fewer characters in length, and will only contain digits (no VeryLongInteger will be negative). The final input line will contain a single zero on a line by itself.

Your program should output the sum of the VeryLongIntegers given in the input.

123456789012345678901234567890 123456789012345678901234567890 123456789012345678901234567890 0

370370367037037036703703703670

0

East Central North America 1996

http://poj.org/problem?id=1503

2017-04-16 09:21:56

1

64

N

0

1

0

1651

【高精度】Adding Reversed Numbers

The Antique Comedians of Malidinesia prefer comedies to tragedies. Unfortunately, most of the ancient plays are tragedies. Therefore the dramatic advisor of ACM has decided to transfigure some tragedies into comedies. Obviously, this work is very hard because the basic sense of the play must be kept intact, although all the things change to their opposites. For example the numbers: if any number appears in the tragedy, it must be converted to its reversed form before being accepted into the comedy play. Reversed number is a number written in arabic numerals but the order of digits is reversed. The first digit becomes last and vice versa. For example, if the main hero had 1245 strawberries in the tragedy, he has 5421 of them now. Note that all the leading zeros are omitted. That means if the number ends with a zero, the zero is lost by reversing (e.g. 1200 gives 21). Also note that the reversed number never has any trailing zeros. ACM needs to calculate with reversed numbers. Your task is to add two reversed numbers and output their reversed sum. Of course, the result is not unique because any particular number is a reversed form of several numbers (e.g. 21 could be 12, 120 or 1200 before reversing). Thus we must assume that no zeros were lost by reversing (e.g. assume that the original number was 12).

The input consists of N cases. The first line of the input contains only positive integer N. Then follow the cases. Each case consists of exactly one line with two positive integers separated by space. These are the reversed numbers you are to add.

For each case, print exactly one line containing only one integer - the reversed sum of two reversed numbers. Omit any leading zeros in the output.

3 24 1 4358 754 305 794

34 1998 1

0

Central Europe 1998

http://poj.org/problem?id=1504

2017-04-16 09:21:56

1

64

N

0

0

0

1652

【初学C_001P1: hello,world

请打印出下列内容: hello,world

P3: 练习11 在你自己的系统中运行“hello, world”程序。再有意去掉程序中的部分内容,看看会得到什么出错信息。 练习12 做个实验,当printf函数的参数字符串中包含 \c(其中c是上面的转义字符序列中未曾出的某一个字符)时,观察一下会出现什么情况。

 

 

 

0

 

 

2017-04-16 09:21:56

1

64

N

3

3

0

1653

【初学C_002P3:华氏温度与摄氏温度对照表

编写程序,请依次输出下列内容: 一、使用“\t”间隔开数据: P4printf("%d\t%d\n",fahr,celsius); 二、设置整型数据的宽度: P6printf("%3d %6d\n",fahr,celsius); 三、设置浮点数据宽度及小数点位数: P7printf("%3.0f %6.1f\n",fahr,celsius);

 

P8:练习13: 修改温度转换程序,使之能在转换表的顶部打印一个标题。 (P1653提交程序要求如下:) fahr: celsius: 0<-> -17.8 20<-> -6.7 40<-> 4.4 60<-> 15.6 80<-> 26.7 100<-> 37.8 120<-> 48.9 140<-> 60.0 160<-> 71.1 180<-> 82.2 200<-> 93.3 220<-> 104.4 240<-> 115.6 260<-> 126.7 280<-> 137.8 300<-> 148.9 P8:练习14: 编写一个程序打印摄氏温度转换为相应华氏温度的转换表。

 

 

0

 

 

2017-04-16 09:21:56

1

64

N

2

2

0

1654

【初学C_003P9for循环应用

P9: 练习1-5: 修改温度转换程序,要求以逆序(即按照从300度到0度的顺序)打印温度转换表。 程序设计,请参考P81.3 for 语句 程序中辅以符号常量有哪些方便之处? (请注意大、小写的区分!) 1.4 符号常量 #define LOWER 0 #define UPPER 300 #define STEP 20

fahr: celsius: 300<-> 148.9 280<-> 137.8 260<-> 126.7 240<-> 115.6 220<-> 104.4 200<-> 93.3 180<-> 82.2 160<-> 71.1 140<-> 60.0 120<-> 48.9 100<-> 37.8 80<-> 26.7 60<-> 15.6 40<-> 4.4 20<-> -6.7 0<-> -17.8

 

 

 

0

 

 

2017-04-16 09:21:56

1

64

N

2

2

0

1655

【初学C_004P11:打印EOF

练习1-6: 验证表达式getchar()!=EOF的值是0还是1。 练习1-7: 编写一个打印EOF值的程序。

程序输出要求: (1)、输出getchar()!=EOF的值 (2)、打印EOF的值

比较下面3条语句: 1c=getchar()!=EOF 2、(c=getchar())!=EOF 3c=(getchar( )!=EOF) 上面3条语句哪些是等价?请关注C的运算优符先级别。

 

 

0

 

 

2017-04-16 09:21:56

1

64

N

1

2

0

1656

【初学C_005P12:double类型

利用double(双精度浮点数)类型可以处理较大的数据。 n!运算是指:1*2*3*4*……*n-1)*n 数据规模增长非常快!

5 文件中包含多个整数,要求程序计算每个整数对应的阶乘!输出时每行一个。 12 23 如何读完整个文件中的数据,请先做完:P1031 TJU_P1007:Step.如何得到输入数据的结束

2147483647(第1行输出MAX_INT) 120 计算5! 479001600 计算12 25852016738884978000000 计算23 12345678901234567 (通过样例,我们会发现double类型能够储存的数据精度是有限的!只有17位!!!最后一位的处理是采用四舍五入方式) 我们发现int数据类型,最大值非常有限!2147483647(第1行输出MAX_INT)

5 12 23

2147483647 120 479001600 25852016738884978000000

0

 

 

2017-04-16 09:21:56

1

64

N

1

2

0

1657

【初学C_006P10:文档的加密与解密

P10 文件的复制 借助getchar()putchar()函数,我们可以将一篇文档非常完整地复制到另一篇文档中去! 如果我们在复制文档的过程中,将字符编号偷偷地进行挪动位置,整篇复制后的文档就没人能看懂了,这就是加密,灰尘老师就是这么干的! 比如:abcd 字符均挪动2个位置后变为: cdef 下面是你的任务: 文档的加密与解密: “22”号是小逗小朋友在路桥小学一(3)班的学号,灰尘老师常常喜欢:给文档加密时加上一个简单的数字。 这里有一篇灰尘老师的加密文档,请你负责将其解密!。

@@@@@@峽倅厓{6?{@@@@@

******welcome lzoier******

 

 

0

 

 

2017-04-16 09:21:56

1

64

N

2

2

0

1658

【初学C_007P13:统计空格,格制表符,换行符

P13:练习1-8 编写程序:统计一篇文档中包含的空格,格制表符,换行符的个数。

 

输出格式如下: printf("%5d%5d%5d\n",n1,n2,n3); n1n2n3分别代表该文档中包含的空格,格制表符,换行符的个数。

 

 

0

 

 

2017-04-16 09:21:56

1

64

N

1

2

0

1659

【初学C_008P13:消减文档空格

P13,练习1-9: 编写一个将输入复制到输出的程序,并将其中连续的多个空格用一个空格代替。 每一行中,最后如果有空格,请将其删除! 在文档的最后换行,在新行上输出文档的大小(单位为:KBbyte)字节)

计算机知识扫盲: 一个换行符号由两个字节构成。 1个字符存储空间为:1Bbyte)字节 1KB=1024B 1MB=1024KB 1GB=1024MB 1TB=1024GB 样例数据中,由于空格不好观察,用“#”替换了,请自行替换回“ ”字符,呵呵…… 说明一下: 1、行尾有多个空格,我在输出文档中没有删除干净,留了一个! 2、由于在文档中要输出额外的内容,(另起一行) 额外的换行 文档大小+Byte 这些都占用字节数量哦!(最后没有换行哦!!!)

 

###******#####welcome#####lzoier#####******#### ww####w.115.com####### name:####13757642773###### password:####quanliyifu###### ###

******#welcome#lzoier#******# ww#w.115.com# name:#13757642773# password:#quanliyifu# 102Byte

0

 

 

2017-04-16 09:21:56

1

64

N

2

3

0

1660

2010NOI导刊_05】汤姆斯文强的天堂梦 (par

<p class="MsoNormal"><span style="font-size: medium;"><strike>汤姆斯</strike>文强的天堂梦 </span></p> <p class="MsoNormal"><span style="font-size: medium;"><span lang="EN-US">        </span>文强生活在一个等级为<span lang="EN-US">0</span>的星球上。那里的<span lang="EN-US">pm2.5</span>指数达到了<span lang="EN-US">2^64</span>(战斗力爆表了。。。)</span></p> <p class="MsoNormal"><span style="font-size: medium;">        而且文强没有签劳动合同 没有维权依据 每天学习工作<span lang="EN-US">12</span>小时和成堆的小强让人忍无可忍。<span lang="EN-US">So</span>他希望去等级为<span lang="EN-US">n</span>的星球去找王二哥。(<span lang="EN-US">0.0</span></span></p> <p class="MsoNormal"><span style="font-size: medium;">        有一些航空公司提供航班 从低等级星球送到高一级星球,有些航线价格很高,有些航线因为种种原因(比如延迟啊)会倒贴你钱。当然也有从高一级送到低等级的 可那是韩亚航空公司的<span lang="EN-US">..</span>文强为了生命安全 打死也不会坐的<span lang="EN-US">…</span></span></p> <p class="MsoNormal"><span style="font-size: medium;">         文强通过谷姐已经知道所有航班的线路和需要支付(或倒贴)的金钱。请聪明的你帮他找条价格最低(甚至得到钱最多的方案)</span></p>

<p><span style="font-size: medium;"><span lang="EN-US" style="font-family: Arial;"> </span></span></p> <p><span style="font-size: medium;">       第一行一个正整数<span lang="EN-US" style="font-family: Arial;">n n<=100 </span>接下来的数据可分为<span lang="EN-US" style="font-family: Arial;">n</span>个段落</span><span lang="EN-US" style="font-size: 9pt; font-family: Arial;"><o:p></o:p></span></p> <p><span style="font-size: medium;">       每段第一行的第一个证书<span lang="EN-US" style="font-family: Arial;">ki</span><span lang="EN-US" style="font-family: Arial;">ki<=100</span>),表示等级为<span lang="EN-US" style="font-family: Arial;">i</span>的星球为<span lang="EN-US" style="font-family: Arial;">ki</span></span><span lang="EN-US" style="font-size: 9pt; font-family: Arial;"><o:p></o:p></span></p> <div style="mso-element:para-border-div;border:none;border-bottom:solid windowtext 1.0pt; mso-border-bottom-alt:solid windowtext .75pt;padding:0cm 0cm 1.0pt 0cm"> <p style="border:none;mso-border-bottom-alt:solid windowtext .75pt;padding: 0cm;mso-padding-alt:0cm 0cm 1.0pt 0cm"><span style="font-size: medium;">       接下来的<span lang="EN-US" style="font-family: Arial;">ki</span>中有<span lang="EN-US" style="font-family: Arial;">Tij</span>行依次表示与等级<span lang="EN-US" style="font-family: Arial;">i</span>,编号为<span lang="EN-US" style="font-family: Arial;">j</span>的星球相连的等级为<span lang="EN-US" style="font-family: Arial;">i-1</span>的星球编号和所需要的费用(负数的话就是收益<span style="font-family: Arial;"> </span>费用绝对值不超过<span lang="EN-US" style="font-family: Arial;">1000</span>)每行以<span lang="EN-US" style="font-family: Arial;">0</span>结尾<span style="font-family: Arial;"> </span>每行航线数不超过<span lang="EN-US" style="font-family: Arial;">100</span></span><span lang="EN-US" style="font-size: 9pt; font-family: Arial;"><o:p></o:p></span></p> </div> <p></p> <p></p> <p></p>

<p><span style="font-size: 9pt;">输出所需的费用</span><span style="font-size: 9pt; font-family: Arial;"> </span><span style="font-size: 9pt;">正数为支出</span><span style="font-size: 9pt; font-family: Arial;"> </span><span style="font-size: 9pt;">负数为收益</span></p> <p><span lang="EN-US" style="font-size: 9pt; font-family: Arial;"><o:p></o:p></span></p> <p></p> <p></p>

3 2 1 15 0 1 5 0 3 1 -5 2 10 0 1 3 0 2 40 0 2 1 1 2 5 3 -5 0 2 -19 3 -20 0

-1

0

<p>对于100%的数据有n<=100,ki<=100</p> <p>注意 有一个大陷阱 好好读题目 0.0</p> <p></p>

noi导刊

2017-04-16 09:21:56

1

128

N

2

4

0

1661

2010NOI导刊_05】克鲁斯的加减法(plus

<p> <span style="font-size:medium;">王二哥认为地球人的加法算式太落后了<span style="font-family:Arial;"> </span>比如说有事想要用加法计算<span style="font-family:Arial;">+15*3 </span>只能写成<span style="font-family:Arial;">+15+15+15 </span>真是浪费脑细胞<span style="font-family:Arial;"> </span>于是<span style="font-family:Arial;"> </span>王二哥设计了一种全新的加法系统<span style="font-family:Arial;">  </span>在原有的基础上<span style="font-family:Arial;"> </span>加入了全新功能<span style="font-family:Arial;"> </span>比如上述可以直接写成<span style="font-family:Arial;">+++15 </span>当然<span style="font-family:Arial;"> </span>对于<span style="font-family:Arial;">-15*3</span>可以写成<span style="font-family:Arial;">---15 </span>一段时间后<span style="font-family:Arial;"> </span>王二哥和他的小伙伴们对那个无穷多的<span style="font-family:Arial;">+-</span>惊呆了。。。<span style="font-family:Arial;"> <span>so</span></span>又把他升级了<span style="font-family:Arial;"> </span>比如<span style="font-family:Arial;">+15*3</span>可以写成<span style="font-family:Arial;">+</span><span style="font-family:Arial;">3</span><span style="font-family:Arial;">15 </span>当然<span style="font-family:Arial;"> -15*3</span>等价于<span style="font-family:Arial;">-</span><span style="font-family:Arial;">3</span><span style="font-family:Arial;">15</span></span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;">当然<span style="font-family:Arial;"> </span>有几个特殊情况</span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;">我们约定</span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;">不会出现<span style="font-family:Arial;">++</span><span style="font-family:Arial;">2</span><span style="font-family:Arial;">15</span>这种混合性奇葩算式<span style="font-family:Arial;"> </span>只会是<span style="font-family:Arial;">+</span><span style="font-family:Arial;">3</span><span style="font-family:Arial;">15</span>或者<span style="font-family:Arial;">+++15</span></span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;">对于<span style="font-family:Arial;">23+15*3-2</span>可以有以下几种可能</span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;"><span style="font-family:Arial;">23+++15-2</span></span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;"><span style="font-family:Arial;">23+(3)15-2</span></span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;"><span style="font-family:Arial;">+23+++15-2</span></span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;"><span style="font-family:Arial;">+23+(3)15-2</span></span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;"><span style="font-family:Arial;">+(1)23+(3)15-(1)2</span></span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;">不会有以下情况</span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;"><span style="font-family:Arial;">(1)23+++15-2</span></span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;"><span style="font-family:Arial;">+23++(2)15-(1)2</span></span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;"><span style="font-family:Arial;">23+++15-2+(0)100</span></span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;"><span style="font-family:Arial;">23-(-3)15-2</span></span><span style="font-size:9pt;font-family:Arial;"></span> </p> <p> <span style="font-size:medium;"><span style="font-family:Arial;"> </span></span> </p> <p> <span style="font-size:medium;">王二哥篡改<span style="font-family:Arial;">noi</span>导刊得到的</span><span style="font-size:9pt;font-family:Arial;"></span> </p>

<p> 一个王二哥专用算式 </p>

<p> 一行 为运算结果 </p>

+123+315-12

66

0

对于20%数据 输入长度不超过10<br /> 对于100%数据 输入长度不超过2000<br />

noi导刊

2017-04-16 09:34:44

1

128

N

2

4

0

1686

2010NOI导刊_05】小明搬家(box

<div style="text-indent: 15.75pt">小明要搬家了,大家都来帮忙。</div> <div style="text-indent: 15.75pt">小明现在住在第N楼,总共K个人要把X个大箱子搬上N楼。</div> <div style="text-indent: 21pt">最开始X个箱子都在1楼,但是经过一段混乱的搬运已经乱掉了。最后大家发现这样混乱地搬运过程效率太低了,于是总结出了提高效率的方法。</div> <div style="text-indent: 21pt">大家的速度都是每分钟上(或下)一层楼。所有向上走的人手中都拿一个箱子,所有向下走的人都不拿箱子。到达第N层立刻放下箱子向下走,到达第一层立刻拿起箱子向上走。当一个人向上走,另一个向下走而在楼道里相遇时,向上走的人将手中的箱子交给另一个人,两人同时反向。即原来拿箱子向上走的人不拿箱子向下走,原来不拿箱子向下走的人现拿着箱子向上走。</div>

<div style="text-indent: 15.75pt">【输入】</div> <div style="text-indent: 21pt">第一行NN≤10^9,KK≤500000),MM≤10^9)分别表示楼层数、人数、还放在一楼地上的箱子数。</div> <div style="text-indent: 21pt">接下来K行,每行两个数AiBi</div> <div style="text-indent: 21pt">Ai表示第i人现在所在的层数,Bi01,为0表示第i人正拿着箱子向上走,为1表示第i人不拿箱子向下走。</div> <div style="text-indent: 21pt">输入满足没有任意两人正在同一楼层,在第一层的人一定正拿着箱子向上走,在第N层的人一定正不拿箱子向下走。</div>

<div style="text-indent: 10.5pt">【输出】</div> <div style="text-indent: 15.75pt">仅包含一个整数,为搬完箱子的时间。</div>

【输入样例】 5 2 4 1 0 3 0

【输出样例】 20 【数据范围】 对于30%的数据有K≤100M≤100; 对于60%的数据有K≤1000M≤109; 对于100%的数据有K≤500000,M≤109

0

 

 

2017-04-16 09:35:46

1

128

N

0

0

0

1662

2010NOI导刊_05】无穷的序列 (seq

<p>王二哥收到一个奇葩的无穷的序列 如下</p> <p>110100100010000......(这是省略号 别想多了)</p> <p>请聪明的你帮更聪明的王二哥以下 王二哥指定一个位置 你告诉他这个位置是0还是1 </p> <p></p>

<p>第一行一个正整数n 表示询问次数</p> <p>接下来是n行 每行一个ai ai表示序列位置</p> <p></p>

<p>n行 每行01 表示序列第ai位的数字</p> <p></p>

4 3 14 7 6

0 0 1 0

0

<p>对于100%的数据</p> <p>n不超过1500000</p> <p>ai不超过2^9</p> <p></p>

noi导刊

2017-04-16 09:21:56

1

128

N

2

4

0

1663

2010NOI导刊_06】油滴扩展(box

<div class="Section1" style="layout-grid:15.6pt"> <p class="MsoNormal"><span lang="EN-US"><span style="mso-spacerun:yes">    </span></span><span style="font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman"">【问题描述】</span></p> <p class="MsoNormal"><span lang="EN-US"><span style="mso-spacerun:yes">    </span></span><span style="font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman"">在一个长方形框子里,最多有</span><span lang="EN-US">N</span><span style="font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman""></span><span lang="EN-US">0<=N<=6</span><span style="font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman""><span class="GramE"></span>相异的点。在其中任何一个点上放一个很小的油滴,那么这个油滴会一直扩展,直到接触到其他油滴或者框子的边界。必须等一个油滴扩展完毕才能放置下一个油滴。那么应该按照怎样的顺序在这</span><span lang="EN-US">N</span><span class="GramE"><span style="font-family:宋体;mso-ascii-font-family: "Times New Roman";mso-hansi-font-family:"Times New Roman""></span></span><span style="font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman"">点上放置油滴,才能使放置完毕后所有油滴占据的总体积最大呢?(不同的油滴不会相互融合)</span></p> <p class="MsoNormal"><span lang="EN-US"><span style="mso-spacerun:yes">    </span></span><span style="font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman"">注:圆的面积公式</span><span lang="EN-US">V =pi*r*r</span><span style="font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman"">,其中</span><span lang="EN-US">r</span><span style="font-family: 宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family:"Times New Roman"">为圆的半径。</span></p> <p class="MsoNormal"><span lang="EN-US"><span style="mso-spacerun:yes">    </span></span></p> <p class="MsoNormal"><span lang="EN-US"><span style="mso-spacerun:yes">    </span></span></p> <p class="MsoNormal"><span lang="EN-US"><span style="mso-spacerun:yes">    </span></span></p> <p class="MsoNormal"><span lang="EN-US"><span style="mso-spacerun:yes"> </span></span></p> <p class="MsoNormal"><span lang="EN-US"><span style="mso-spacerun:yes">   </span></span></p> </div>

<p class="MsoNormal"><span style="font-family: 宋体;">【输入】</span></p> <p class="MsoNormal"><span style="font-family: 宋体;">第一行一个整数</span><span lang="EN-US">N</span><span style="font-family: 宋体;"></span></p> <p class="MsoNormal"><span style="font-family: 宋体;">第二行为长方形边框一个顶点及其对角顶点的坐标:</span><span lang="EN-US">x</span><span style="font-family: 宋体;"></span><span lang="EN-US">y</span><span style="font-family: 宋体;"></span><span lang="EN-US">x'</span><span style="font-family: 宋体;"></span><span lang="EN-US">y'</span><span style="font-family: 宋体;"></span></p> <p class="MsoNormal" style="text-indent: 21.75pt;"><span lang="EN-US"> </span></p> <p class="MsoNormal" style="text-indent: 21.75pt;"><span lang="EN-US"> </span></p> <p class="MsoNormal"><span lang="EN-US">  </span></p> <p class="MsoNormal"><span style="font-family: 宋体;">接下去</span><span lang="EN-US">N</span><span style="font-family: 宋体;">行,每行两个整数</span><span lang="EN-US">xi</span><span style="font-family: 宋体;"></span><span class="SpellE"><span lang="EN-US">yi</span></span><span style="font-family: 宋体;">,表示盒子内</span><span lang="EN-US">N</span><span class="GramE"><span style="font-family: 宋体;"></span></span><span style="font-family: 宋体;">点的坐标。</span></p> <p class="MsoNormal"><span style="font-family: 宋体;">以上所有的整数都在</span><span lang="EN-US">[-1000,1000] </span><span style="font-family: 宋体;">内。</span></p>

<p class="MsoNormal"><span style="font-family: 宋体;">【输出】</span></p> <p class="MsoNormal"><span lang="EN-US">    </span><span style="font-family: 宋体;">一行,一个整数,长方形<span class="GramE">盒子剩余的</span>最小空间(结果四<span class="GramE">舍五入输</span>出)。</span></p> <p></p>

【输入样例】 2 0 0 10 10 3 3 7 7

【输出样例】 50

0

 

 

2017-04-16 09:21:56

1

128

N

0

4

0

1664

2010NOI导刊_06】数列(sequence

<p class="MsoNormal">【问题描述】</p> <p class="MsoNormal"><span lang="EN-US">        </span>虽然<span class="SpellE"><span lang="EN-US">msh</span></span>长大了,但她还是很喜欢找点游戏自娱自乐。</p> <p class="MsoNormal">        有一天,她在纸上写了一串数字:<span lang="EN-US">1</span><span lang="EN-US">1</span><span lang="EN-US">2</span><span lang="EN-US">5</span><span lang="EN-US">4</span></p> <p class="MsoNormal">        接着她擦掉了一个<span lang="EN-US">1</span>,结果发现剩下<span lang="EN-US">1</span><span lang="EN-US">2</span><span lang="EN-US">4</span>都在自己所在的位置上,即<span lang="EN-US">1</span>在第<span lang="EN-US">1</span>位,<span lang="EN-US">2</span>在第<span lang="EN-US">2</span>位,<span lang="EN-US">4</span>在第<span lang="EN-US">4</span>位。</p> <p class="MsoNormal">        她希望擦掉某些数后,剩下的数列中在自己位置上的数尽量多。她发现这个游戏很好玩,于是开始乐此不疲地玩起来……不过她不能确定最多能有多少个数在自己的位置上,所以找到你,请你帮忙计算一下!</p> <p class="MsoNormal"></p> <p></p>

<p class="MsoNormal">【输入】</p> <p class="MsoNormal"><span lang="EN-US">    </span>第一行为一个数<span lang="EN-US">n</span>,表示数列的长度。</p> <p class="MsoNormal"><span lang="EN-US">    </span>接下来一行为<span lang="EN-US">n</span><span class="GramE"></span>用空格隔开的正整数,第 行表示数<span lang="EN-US">Ai</span></p> <p class="MsoNormal"></p> <p></p>

<p class="MsoNormal">【输出】</p> <p class="MsoNormal" style="TEXT-INDENT: 21.75pt">一行一个整数,表示擦掉某些数后,最后剩下的数列中最多能有多少个数在自己的位置上,即<span lang="EN-US">Ai=<span class="SpellE">i</span></span>最多能有多少。</p> <p class="MsoNormal"><span lang="EN-US"> </span></p> <p></p>

【样例】 sequence .in 5 1 1 2 5 4

sequence .out 3 数据规模 对于20%的数据,n<=20; 对于60%的数据,n<=100; 对于100%的数据,n<=1000

0

 

 

2017-04-16 09:21:56

1

128

N

0

4

0

1665

2010NOI导刊_06SOFTWARE

<p>       一个软件开发公司同时要开发两个软件,并且要同时交付给用户,现在公司为了尽快完成这一任务,将每个软件划分成<span lang="EN-US">m</span><span class="GramE"></span>模块,由公司里的技术人员分工完成,每个技术人员完成同一软件的不同模块的所用的天数是相同的,并且是已知的,但完成不同软件的一个模块的时间是不同的,</p> <p>        每个技术人员在同一时刻只能做<span class="GramE">一个模块,一个模块</span>只能由一个人独立完成而不能由多人协同完成。一个技术人员在整个开发期内完成一个模块以后可以接着做任一软件的任一模块。</p> <p>       写一个程序,求出公司最早能在什么时候交付软件。</p> <p></p>

<p class="MsoNormal" style="TEXT-INDENT: 21.75pt">【输入】</p> <p class="MsoNormal" style="TEXT-INDENT: 21.75pt">输入文件第一行包含两个由空格隔开的整数<span lang="EN-US">n</span><span lang="EN-US">m</span>,其中<span lang="EN-US">1<=n<=100</span><span lang="EN-US">1<=m<=100</span></p> <p class="MsoNormal" style="TEXT-INDENT: 21.75pt">接下来的<span lang="EN-US">n</span><span class="GramE">行,每行包</span>含两个用空格隔开的整数<span lang="EN-US">d1</span><span lang="EN-US">d2</span></p> <p class="MsoNormal" style="TEXT-INDENT: 21.75pt"><span lang="EN-US">d1</span>表示该技术人员完成第一个软件中的一个模块所需的天数,</p> <p class="MsoNormal" style="TEXT-INDENT: 21.75pt"><span lang="EN-US">d2</span>表示该技术人员完成第二个软件中的一个模块所需的天数,其中<span lang="EN-US">l <=d1</span><span lang="EN-US">d2<= l00</span></p> <p class="MsoNormal" style="TEXT-INDENT: 21.75pt"></p> <p></p>

<p class="MsoNormal">【输出】</p> <p class="MsoNormal" style="TEXT-INDENT: 21.75pt">输出文件仅有一行包含一个整数<span lang="EN-US">d</span>,表示公司最早能于<span lang="EN-US">d</span>天后交付软件。</p> <p></p>

【样例】 SOFTWARE.IN 3 20 1 1 2 4 1 6

SOFTWARE.OUT 18 【样例】 最快的方案是: 第一个技术人员完成第二个软件的18个模块,用时18天; 第三个技术人员完成第一个软件的18个模块,用时18天; 其余的模块由第二个技术人员完成,用时12天; 做完所有模块需要18天。 如果第一个技术人员完成第二个软件的17个模块,第三个技术人员完成第一个软件的17个模块,其余的模块由第二个技术人员完成,需要用时18天,做完所有模块仍然需要18天,所以少于18天不可能做完所有模块。

0

 

 

2017-04-16 09:21:56

1

128

N

0

3

0

1666

2010NOI导刊_06】黑匣子(blackbox)

<p class="MsoNormal"><span lang="EN-US">       Black Box</span>是一种原始的数据库。它可以储存一个整数数组,还有一个特别的变量 <span lang="EN-US">i </span></p> <p class="MsoNormal">       最开始的时候<span lang="EN-US">Black Box</span>是空的,而 <span lang="EN-US">i </span>等于<span lang="EN-US">0</span></p> <p class="MsoNormal">    这个<span lang="EN-US">Black Box</span>要处理一串命令。</p> <p class="MsoNormal"></p> <p class="MsoNormal"><span lang="EN-US">    </span>命令只有两种:</p> <p class="MsoNormal"><span lang="EN-US">    ADDx</span>:把<span lang="EN-US">x</span>元素放进<span lang="EN-US">Black Box</span></p> <p class="MsoNormal"><span lang="EN-US">   GET</span><span lang="EN-US">   i </span><span lang="EN-US">1</span>,然后输出<span lang="EN-US">Black Box</span>中第 <span lang="EN-US">i </span>小的数。</p> <p class="MsoNormal" style="text-indent:21.75pt">记住:第 <span lang="EN-US">i </span>小的数,就是<span lang="EN-US">Black Box</span>里的数的按从小到大的顺序排序后的第 <span lang="EN-US">i </span>个元素。</p> <p class="MsoNormal" style="text-indent:21.75pt"><span lang="EN-US"> </span></p> <p class="MsoNormal"><span lang="EN-US">    </span>例如:我们来演示一下一个有<span lang="EN-US">11</span>个命令的命令串。(如下图所示)</p> <table class="MsoTableGrid" border="1" cellspacing="0" cellpadding="0" style="border-collapse:collapse;border:none;mso-border-alt:solid windowtext .5pt; mso-yfti-tbllook:480;mso-padding-alt:0cm 5.4pt 0cm 5.4pt;mso-border-insideh: .5pt solid windowtext;mso-border-insidev:.5pt solid windowtext"> <tbody> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">序号</p> </td> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-left:none;mso-border-left-alt:solid windowtext .5pt;mso-border-alt: solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">操作</p> </td> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-left:none;mso-border-left-alt:solid windowtext .5pt;mso-border-alt: solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">i</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border:solid windowtext 1.0pt; border-left:none;mso-border-left-alt:solid windowtext .5pt;mso-border-alt: solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">数据库</p> </td> <td width="114" valign="top" style="width:85.25pt;border:solid windowtext 1.0pt; border-left:none;mso-border-left-alt:solid windowtext .5pt;mso-border-alt: solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">输出</p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">1</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">ADD(3)</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">0</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">3</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US"> </span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">2</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">GET</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">1</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">3</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">3</span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">3</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">ADD(1)</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">1</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">1,3</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US"> </span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">4</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">GET</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">2</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">1,3</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">3</span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">5</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">ADD(-4)</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">2</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">-4,1,3</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US"> </span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">6</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">ADD(2)</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">2</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">-4,1,2,3</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US"> </span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">7</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">ADD(8)</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">2</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">-4,1,2,3,8</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US"> </span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">8</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">ADD(-1000)</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">2</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">-1000,-4,1,2,3,8</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US"> </span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">9</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">GET</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">3</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">-1000,-4,1,2,3,8</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">1</span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">10</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">GET</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">4</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">-1000,-4,1,2,3,8</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">2</span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">11</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">ADD(2)</span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">4</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">-1000,-4,1,2,2,3,8</span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US"> </span></p> </td> </tr> </tbody> </table> <p class="MsoNormal" style="text-indent:21.75pt"><span lang="EN-US"> </span></p> <p class="MsoNormal"><span lang="EN-US">    </span>现在要求找出对于给定的命令串的最好的处理方法。</p> <p class="MsoNormal"><span lang="EN-US">    ADD</span><span lang="EN-US">GET</span>命令分别最多有<span lang="EN-US">200000</span>个。</p> <p class="MsoNormal"><span lang="EN-US">    </span>现在用两个整数数组来表示命令串:</p> <p class="MsoNormal"><span lang="EN-US">    1</span><span lang="EN-US">A(1), A(2),</span>…<span lang="EN-US">A(M) </span>:一串将要被放进<span lang="EN-US">Black Box</span>的元素。每个数都是绝对值不超过<span lang="EN-US">2000000000</span>的整数,<span lang="EN-US">M<=200000</span>。例如上面的例子就是<span lang="EN-US">A=</span><span lang="EN-US">3,1,-4,2,8,-1000,2</span>)。</p> <p class="MsoNormal"><span lang="EN-US">    2.u(1)</span><span lang="EN-US">.u(1)</span>…<span lang="EN-US">u(N)</span>,:表示第<span lang="EN-US">.u(j)</span>个元素被放进了<span lang="EN-US">Black Box</span>里后就出现一个<span lang="EN-US">GET</span>命令。例如上面的例子中<span lang="EN-US">u=(1,2,6,6)</span>输入数据不用判错。</p> <p></p>

<p> 【输入】</p> <p class="MsoNormal"><span lang="EN-US">    </span>第一行,两个整数,<span lang="EN-US">M</span><span lang="EN-US">N</span></p> <p class="MsoNormal"><span lang="EN-US">    </span>第二行,<span lang="EN-US">M</span><span class="GramE"></span>整数.表示<span lang="EN-US">A(l)</span>……<span lang="EN-US">A(M)</span></p> <p class="MsoNormal">   第三行,<span lang="EN-US">N</span><span class="GramE"></span>整数,表示<span lang="EN-US">u(1) </span>…… <span lang="EN-US">u(N)</span></p>

<p class="MsoNormal" style="TEXT-INDENT: 21.75pt">【输出】</p> <p class="MsoNormal" style="TEXT-INDENT: 21.75pt">输出<span lang="EN-US">Black Box </span>根据<span class="GramE">命令串所得出</span>的串,一个数字一行。</p> <p></p>

【输入样例】 7 4 3 1 -4 2 8 -1000 2 1 2 6 6

【输出样例】 3 3 1 2 数据规模: 对于30%的数据, M<=10000; 对于5%的数据, M<=100000; 对于100%的数据,M<=200000

0

 

 

2017-04-16 09:21:56

1

128

N

0

2

0

1667

2010NOI导刊_01】淘汰赛制(elimination.pas/c/cpp)

<p class="MsoNormal" style="text-indent:12.0pt;mso-char-indent-count:1.0"><span style="font-size: 12pt;">题目</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> <p class="MsoNormal"><span style="font-size: 12pt;">(提高组</span><span style="font-size:12.0pt"> </span><span style="font-size: 12pt;">时间:</span><span lang="EN-US" style="font-size:12.0pt">3</span><span style="font-size: 12pt;">个小时)</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> <table class="MsoNormalTable" border="1" cellspacing="0" cellpadding="0" style="margin-left:-30.6pt;border-collapse:collapse;border:none;mso-border-alt: solid windowtext .5pt;mso-yfti-tbllook:480;mso-padding-alt:0cm 5.4pt 0cm 5.4pt; mso-border-insideh:.5pt solid windowtext;mso-border-insidev:.5pt solid windowtext"> <tbody> <tr> <td width="96" valign="top" style="width:71.7pt;border:solid windowtext 1.0pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span style="font-size: 12pt;">题目名称</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> </td> <td valign="top" style="border:solid windowtext 1.0pt;border-left:none; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span style="font-size: 12pt;">淘汰赛制</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> </td> <td valign="top" style="border:solid windowtext 1.0pt;border-left:none; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span style="font-size: 12pt;">种树</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> </td> <td valign="top" style="border:solid windowtext 1.0pt;border-left:none; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span style="font-size: 12pt;">方程的解</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> </td> <td valign="top" style="border:solid windowtext 1.0pt;border-left:none; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span style="font-size: 12pt;">物流运输</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> </td> </tr> <tr> <td width="96" valign="top" style="width:71.7pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span style="font-size: 12pt;">题目程序名</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">Elimination.pas/c/cpp<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">Tree.pas/c/cpp<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">Equation.pas/c/cpp<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">Trans.pas/c/cpp<o:p></o:p></span></p> </td> </tr> <tr> <td width="96" valign="top" style="width:71.7pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span style="font-size: 12pt;">输入文件名</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">Elimination.in <o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">Tree.in<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">Equation.in<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">Trans.in<o:p></o:p></span></p> </td> </tr> <tr> <td width="96" valign="top" style="width:71.7pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span style="font-size: 12pt;">输出文件名</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">Elimination.out<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">Tree.out<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">Equation.out<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">Trans.out<o:p></o:p></span></p> </td> </tr> <tr> <td width="96" valign="top" style="width:71.7pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span style="font-size: 12pt;">测试点时限</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">1s<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">1s<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">1s<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">1s<o:p></o:p></span></p> </td> </tr> <tr> <td width="96" valign="top" style="width:71.7pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span style="font-size: 12pt;">测试点个数</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">10<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">10<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">10<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">10<o:p></o:p></span></p> </td> </tr> <tr> <td width="96" valign="top" style="width:71.7pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span style="font-size: 12pt;">测试点分值</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">10<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">10<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">10<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">10<o:p></o:p></span></p> </td> </tr> <tr> <td width="96" valign="top" style="width:71.7pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span style="font-size: 12pt;">内存限制</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">256MB<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">256MB<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">256MB<o:p></o:p></span></p> </td> <td valign="top" style="border-top:none;border-left:none;border-bottom:solid windowtext 1.0pt; border-right:solid windowtext 1.0pt;mso-border-top-alt:solid windowtext .5pt; mso-border-left-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US" style="font-size:12.0pt">256MB<o:p></o:p></span></p> </td> </tr> </tbody> </table> <p></p> <p><span lang="EN-US" style="text-indent: -18pt; font-size: 12pt;">1.<span style="font-size: 7pt; font-family: 'Times New Roman';">      </span></span><span style="text-indent: -18pt; font-size: 12pt; font-family: 宋体;">淘汰赛制</span><span lang="EN-US" style="text-indent: -18pt; font-size: 12pt;">(elimination.pas/c/cpp)</span></p> <p class="MsoNormal"><span style="font-size:12.0pt;font-family:宋体;mso-ascii-font-family: "Times New Roman";mso-hansi-font-family:"Times New Roman"">【问题描述】</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> <p class="MsoNormal"><span style="font-size:12.0pt;font-family:宋体;mso-ascii-font-family: "Times New Roman";mso-hansi-font-family:"Times New Roman"">淘汰赛制是一种极其残酷的比赛制度。</span><span lang="EN-US" style="font-size:12.0pt">2<sup>n</sup></span><span style="font-size: 12.0pt;font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman"">名选手分别标号</span><span lang="EN-US" style="font-size:12.0pt">1</span><span style="font-size:12.0pt;font-family:宋体;mso-ascii-font-family:"Times New Roman"; mso-hansi-font-family:"Times New Roman""></span><span lang="EN-US" style="font-size:12.0pt">2</span><span style="font-size:12.0pt;font-family: 宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family:"Times New Roman""></span><span lang="EN-US" style="font-size:12.0pt">3,</span><span style="font-size:12.0pt; font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman"">…</span><span lang="EN-US" style="font-size:12.0pt">2<sup>n-1</sup></span><span style="font-size:12.0pt;font-family:宋体;mso-ascii-font-family:"Times New Roman"; mso-hansi-font-family:"Times New Roman""></span><span lang="EN-US" style="font-size:12.0pt">2<sup>n</sup></span><span style="font-size:12.0pt; font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman"">,他们将要参加</span><span lang="EN-US" style="font-size:12.0pt">n</span><span style="font-size:12.0pt;font-family:宋体;mso-ascii-font-family:"Times New Roman"; mso-hansi-font-family:"Times New Roman"">轮的激烈角逐。每一轮中,将所有参加该轮的选手按标号从小到大排序后,第</span><span lang="EN-US" style="font-size:12.0pt">1</span><span style="font-size:12.0pt; font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman"">位与第</span><span lang="EN-US" style="font-size:12.0pt">2</span><span style="font-size:12.0pt;font-family:宋体;mso-ascii-font-family:"Times New Roman"; mso-hansi-font-family:"Times New Roman"">位比赛,第</span><span lang="EN-US" style="font-size:12.0pt">3</span><span style="font-size:12.0pt;font-family: 宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family:"Times New Roman"">位与第</span><span lang="EN-US" style="font-size:12.0pt">4</span><span style="font-size:12.0pt; font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman"">位比赛,第</span><span lang="EN-US" style="font-size:12.0pt">5</span><span style="font-size:12.0pt;font-family:宋体;mso-ascii-font-family:"Times New Roman"; mso-hansi-font-family:"Times New Roman"">位与第</span><span lang="EN-US" style="font-size:12.0pt">6</span><span style="font-size:12.0pt;font-family: 宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family:"Times New Roman"">位比赛……只有每场比赛的胜利者才有机会参加下一轮的比赛(不会有平局)。这样,每轮将淘汰一半的选手。</span><span lang="EN-US" style="font-size:12.0pt">n</span><span style="font-size:12.0pt; font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman"">轮过后,只剩下一名选手,该选手即为冠军。</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> <p></p> <p></p>

<p><span style="font-size: 12pt;">输入文件</span><span lang="EN-US" style="font-size:12.0pt;font-family:"Times New Roman";mso-fareast-font-family: 宋体;mso-font-kerning:1.0pt;mso-ansi-language:EN-US;mso-fareast-language:ZH-CN; mso-bidi-language:AR-SA">elimination. in </span><span style="font-size: 12pt;">。第一行是一个整数</span><span lang="EN-US" style="font-size:12.0pt;font-family:"Times New Roman";mso-fareast-font-family: 宋体;mso-font-kerning:1.0pt;mso-ansi-language:EN-US;mso-fareast-language:ZH-CN; mso-bidi-language:AR-SA">n (1<=n<=10)</span><span style="font-size: 12pt;">,表示总轮数。接下来</span><span lang="EN-US" style="font-size:12.0pt;font-family:"Times New Roman";mso-fareast-font-family: 宋体;mso-font-kerning:1.0pt;mso-ansi-language:EN-US;mso-fareast-language:ZH-CN; mso-bidi-language:AR-SA">2<sup>n</sup></span><span style="font-size: 12pt;">行,每行</span><span lang="EN-US" style="font-size:12.0pt;font-family:"Times New Roman";mso-fareast-font-family: 宋体;mso-font-kerning:1.0pt;mso-ansi-language:EN-US;mso-fareast-language:ZH-CN; mso-bidi-language:AR-SA">2<sup>n</sup></span><span style="font-size: 12pt;">个整数,第</span><span lang="EN-US" style="font-size:12.0pt;font-family:"Times New Roman";mso-fareast-font-family: 宋体;mso-font-kerning:1.0pt;mso-ansi-language:EN-US;mso-fareast-language:ZH-CN; mso-bidi-language:AR-SA">i</span><span style="font-size: 12pt;">行第</span><span lang="EN-US" style="font-size:12.0pt;font-family:"Times New Roman";mso-fareast-font-family: 宋体;mso-font-kerning:1.0pt;mso-ansi-language:EN-US;mso-fareast-language:ZH-CN; mso-bidi-language:AR-SA">j</span><span style="font-size: 12pt;">个是</span><span lang="EN-US" style="font-size:12.0pt;font-family:"Times New Roman";mso-fareast-font-family: 宋体;mso-font-kerning:1.0pt;mso-ansi-language:EN-US;mso-fareast-language:ZH-CN; mso-bidi-language:AR-SA">p<sub>ij</sub>(0<=p<sub>ij</sub><=100</span><span style="font-size: 12pt;"></span><span lang="EN-US" style="font-size:12.0pt; font-family:"Times New Roman";mso-fareast-font-family:宋体;mso-font-kerning:1.0pt; mso-ansi-language:EN-US;mso-fareast-language:ZH-CN;mso-bidi-language:AR-SA">p<sub>ii</sub>=0</span><span style="font-size: 12pt;"></span><span lang="EN-US" style="font-size:12.0pt; font-family:"Times New Roman";mso-fareast-font-family:宋体;mso-font-kerning:1.0pt; mso-ansi-language:EN-US;mso-fareast-language:ZH-CN;mso-bidi-language:AR-SA">p<sub>ij</sub>+p<sub>ji</sub>=100)</span><span style="font-size: 12pt;">,表示第</span><span lang="EN-US" style="font-size:12.0pt; font-family:"Times New Roman";mso-fareast-font-family:宋体;mso-font-kerning:1.0pt; mso-ansi-language:EN-US;mso-fareast-language:ZH-CN;mso-bidi-language:AR-SA">i</span><span style="font-size: 12pt;">号选手与第</span><span lang="EN-US" style="font-size:12.0pt; font-family:"Times New Roman";mso-fareast-font-family:宋体;mso-font-kerning:1.0pt; mso-ansi-language:EN-US;mso-fareast-language:ZH-CN;mso-bidi-language:AR-SA">j</span><span style="font-size: 12pt;">号选手比赛获胜的概率。</span></p> <p></p>

<p class="MsoNormal"><span style="font-size: 12pt;">输出文件</span><span lang="EN-US" style="font-size:12.0pt">elimination. out</span><span style="font-size: 12pt;">。只有一个整数</span><span lang="EN-US" style="font-size:12.0pt">c </span><span style="font-size: 12pt;">,表示夺冠概率最大的选手编号(若有多位选手,输出编号最小者)。</span><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></p> <p></p>

【样例输入】 2 0 90 50 50 10 0 10 10 50 90 0 50 50 90 50 0

【样例输出】 1 【数据规模】 30%的数据满足n<=3 100%的数据满足n<=10

0

 

 

2017-04-16 09:21:56

1

128

N

0

2

0

1668

2010NOI导刊_01】种树(Tree.pas/c/cpp

<p class="MsoNormal"><span style="font-size: 12pt;">【问题描述】<span lang="EN-US"><o:p></o:p></span></span></p> <p class="MsoNormal"><span style="font-size: 12pt;">一条街的一边有几座房子。因为环保原因居民想要在路边种些树。路边的地区被分割成块,并被编号为<span lang="EN-US">1</span>…<span lang="EN-US">n </span>。每个块的大小为一个单位尺寸并最多可种一棵树。每个居民想在门前种些树并指定了三个号码<span lang="EN-US">b</span><span lang="EN-US">e</span><span lang="EN-US">t </span>。这三个数表示该居民想在<span lang="EN-US">b</span><span lang="EN-US">e</span>之间最少种<span lang="EN-US">t</span>棵树。当然,<span lang="EN-US">b<=e </span>,居民必须保证在指定地区不能种多于地区被分割成块数的树,即要求<span lang="EN-US">t<=e-b+1 </span>。允许居民想种树的各自区域可以交叉。出于资金短缺的原因,环保部门请你求出能够满足所有居民的要求,需要种树的最少数量。<span lang="EN-US"><o:p></o:p></span></span></p> <p></p>

<p class="MsoNormal"><span style="font-size: 12pt;">【文件输入】<span lang="EN-US"><o:p></o:p></span></span></p> <p class="MsoNormal"><span style="font-size: 12pt;">第一行为<span lang="EN-US">n </span>,表示区域的个数;<span lang="EN-US"><o:p></o:p></span></span></p> <p class="MsoNormal"><span style="font-size: 12pt;">第二行为<span lang="EN-US">h </span>,表示房子的数目;<span lang="EN-US"><o:p></o:p></span></span></p> <p class="MsoNormal"><span style="font-size: 12pt;">下面<span lang="EN-US">h</span>行描述居民的需要:<span lang="EN-US">b e t (0<b<=e<=30000 ,r<=e-b+1)</span>分别用一个空格分开。<span lang="EN-US"><o:p></o:p></span></span></p> <p></p>

<p class="MsoNormal"><span style="font-size: 12pt;">【文件输出】<span lang="EN-US"><o:p></o:p></span></span></p> <p class="MsoNormal"><span style="font-size: 12pt;">输出为满足所有要求的最少树的数量。<span lang="EN-US"><o:p></o:p></span></span></p> <p></p>

【样例输入】 9 4 1 4 2 4 6 2 8 9 2 3 5 2

【样例输出】 5 【数据规模】 30%的数据满足0<n<=1000 ,0<h<=500  100%的数据满足n<=30000 ,h<=5000

0

 

 

2017-04-16 09:21:56

1

128

N

0

1

0

1669

2010NOI导刊_01】方程的解(equation.pas/c/cpp

 

<p class="MsoNormal"><span style="font-size: 12pt;">【文件输入】<span lang="EN-US"><o:p></o:p></span></span></p> <p class="MsoNormal"><span style="font-size: 12pt;">输入文件<span lang="EN-US">equation. in </span>有且只有一行,为用空格隔开的两个正整数,依次为<span lang="EN-US">k,x</span><span lang="EN-US"><o:p></o:p></span></span></p> <p></p>

<p class="MsoNormal"><span style="font-size: 12pt;">【文件输出】<span lang="EN-US"><o:p></o:p></span></span></p> <p class="MsoNormal"><span style="font-size: 12pt;">输出文件<span lang="EN-US">equation. out</span>有且只有一行,为方程的正整数解组数。<span lang="EN-US"><o:p></o:p></span></span></p> <p></p>

【样例输入】 3 2

【样例输出】 3 【数据范围】 对于40%的数据,ans<=1016; 对于100%的数据,看<=100,x<=231-1,k<=g(x)

0

 

 

2017-04-16 09:21:56

1

128

N

0

0

0

1670

2010NOI导刊_01】物流运输(trans.pas/c/cpp

<p class="MsoNormal"><span style="font-size: 12pt;">【问题描述】<span lang="EN-US"><o:p></o:p></span></span></p> <p class="MsoNormal"><span style="font-size: 12pt;">物流公司要把一批货物从码头<span lang="EN-US">A</span>运到码头<span lang="EN-US">B</span>。由于货物量比较大,需要<span lang="EN-US">n</span>天才能运完。货物运输过程中一般要转停好几个码头。物流公司通常会设计一条固定的运输路线,以便对整个运输过程实施严格的管理和跟踪。由于各种因素的存在,有的时候某个码头会无法装卸货物。这时候就必须修改运输路线,让货物能够按时到达目的地。但是修改路线是一件十分麻烦的事情,会带来额外的成本。因此物流公司希望能够订一个<span lang="EN-US">n</span>天的运输计划,使得总成本尽可能的小。<span lang="EN-US"><o:p></o:p></span></span></p> <p></p>

<p class="MsoNormal"><span style="font-size: 12pt;">【文件输入】<span lang="EN-US"><o:p></o:p></span></span></p> <p class="MsoNormal"><span style="font-size: 12pt;">第一行是四个整数<span lang="EN-US">n(1<=n<=100),m(1<=m<=20),K</span><span lang="EN-US">e</span><span lang="EN-US">n</span>表示货物运输所需天数,<span lang="EN-US">m </span>表示码头总数,<span lang="EN-US">K</span>表示每次修改运输路线所需成本。接下来<span lang="EN-US">e</span>行每行是一条航线描述,包括了三个整数,依次表示航线连接的两个码头编号以及航线长度(<span lang="EN-US">>0</span>)。其中码头<span lang="EN-US">A</span>编号为<span lang="EN-US">1</span>,码头<span lang="EN-US">B</span>编号为<span lang="EN-US">m</span>。单位长度的运输费用为<span lang="EN-US">1</span>。航线是双向的。再接下来一行是一个整数<span lang="EN-US">d,</span>后面的<span lang="EN-US">d</span>行每行是三个整数<span lang="EN-US">P</span><span lang="EN-US">1<P<m</span><span lang="EN-US">,a,b (1<=a<=b<=n)</span>。表示编号为<span lang="EN-US">P</span>的码头从第<span lang="EN-US">a</span>天到第<span lang="EN-US">b</span>天无法装卸货物(含头尾)。同一个码头有可能在多个时间段内不可用。但任何时间都存在至少一条从码头<span lang="EN-US">A</span>到码头<span lang="EN-US">B</span>的运输路线。<span lang="EN-US"><o:p></o:p></span></span></p> <p></p>

<p class="MsoNormal"><span style="font-size: 12pt;">【文件输出】<span lang="EN-US"><o:p></o:p></span></span></p> <p class="MsoNormal"><span style="font-size: 12pt;">包括了一个整数表示最小的总成本。总成本<span lang="EN-US">=n</span>天运输路线长度之和<span lang="EN-US">+ K* </span>改变运输路线的次数。<span lang="EN-US"><o:p></o:p></span></span></p> <p></p>

【样例输入】 5 5 10 8 1 2 1 1 3 3 1 4 2 2 3 2 2 4 4 3 4 1 3 5 2 4 5 2 4 2 2 3 3 1 1 3 3 3 4 4 5

【样例输出】 32

0

 

 

2017-04-16 09:21:56

1

128

N

0

2

0

1671

2010NOI导刊_02】符文之语(chars.pas/c/cpp

<p class="MsoNormal"><b><span style="font-size: 16pt;">试题</span></b><b><span lang="EN-US" style="font-size:16.0pt"><o:p></o:p></span></b></p> <table class="MsoNormalTable" border="1" cellspacing="0" cellpadding="0" style="border-collapse:collapse;border:none;mso-border-alt:solid windowtext .5pt; mso-yfti-tbllook:480;mso-padding-alt:0cm 5.4pt 0cm 5.4pt;mso-border-insideh: .5pt solid windowtext;mso-border-insidev:.5pt solid windowtext"> <tbody> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span style="font-size: 12pt;">题目名称</span></b><b><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-left:none;mso-border-left-alt:solid windowtext .5pt;mso-border-alt: solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b>符文之语</b><b><span lang="EN-US"><o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-left:none;mso-border-left-alt:solid windowtext .5pt;mso-border-alt: solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b>最接近神的人</b><b><span lang="EN-US"><o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border:solid windowtext 1.0pt; border-left:none;mso-border-left-alt:solid windowtext .5pt;mso-border-alt: solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b>古代人的难题</b><b><span lang="EN-US"><o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border:solid windowtext 1.0pt; border-left:none;mso-border-left-alt:solid windowtext .5pt;mso-border-alt: solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b>宝物筛选</b><b><span lang="EN-US"><o:p></o:p></span></b></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span style="font-size: 12pt;">提交程序名</span></b><b><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">chars<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">sophist<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">puzzle<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">treasure<o:p></o:p></span></b></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span style="font-size: 12pt;">输入文件名</span></b><b><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">chars.in<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">sophist.in<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">puzzle.in<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">treasure.in<o:p></o:p></span></b></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span style="font-size: 12pt;">输出文件名</span></b><b><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">chars.out<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">sophist. out<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">puzzle.out<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">treasure.out<o:p></o:p></span></b></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span style="font-size: 12pt;">空间限制</span></b><b><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">50MB<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">50MB<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">50MB<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">50MB<o:p></o:p></span></b></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span style="font-size: 12pt;">时间限制</span></b><b><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">1s<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">1s<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">1s<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">1s<o:p></o:p></span></b></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span style="font-size: 12pt;">各题测试点数</span></b><b><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">10<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">10<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">10<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">10<o:p></o:p></span></b></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span style="font-size: 12pt;">各测试点分值</span></b><b><span lang="EN-US" style="font-size:12.0pt"><o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">10<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">10<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">10<o:p></o:p></span></b></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt">10<o:p></o:p></span></b></p> </td> </tr> </tbody> </table> <p class="MsoNormal"><b><span lang="EN-US" style="font-size:14.0pt"> </span></b></p> <p class="MsoNormal">故事背景:<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0">传说中珠穆朗玛峰下有座古代人修建的神庙,神庙的地下室里有古代王室的遗产,但数千年来从未有人到达过……<span lang="EN-US">  </span>探险者小<span lang="EN-US">FF</span>一直梦想成为世界上最富有的人和最杰出的探险家并被永载史册。在证明了这个洞确实存在后,小<span lang="EN-US">FF</span>做好了充分的准备,来到了神庙。</p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0"> <p class="MsoNormal"><b><span style="font-size: 15pt;">【题目描述】</span></b><b><span lang="EN-US" style="font-size:15.0pt"><o:p></o:p></span></b></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0">当小<span lang="EN-US">FF</span>来到神庙时,神庙已经破败不堪了。但神庙的中央有一个光亮如新的石台。小<span lang="EN-US">FF</span>走进石台,发现石台上有一个数串,而数串的上方刻着一串古老的符文之语。精通古符文之语的小<span lang="EN-US">FF</span>不费吹灰之力就读懂了文章的意思,其大意是:对于石台上的一串数字,你可以在适当的位置加入乘号(设加了<span lang="EN-US">k</span>个,当然也可不加,即分成<span lang="EN-US">k+1</span>个部分),设这<span lang="EN-US">k+1</span>个部分的乘积(如果<span lang="EN-US">k=0</span>,则乘积即为原数串的值)对<span lang="EN-US">m</span>的余数(即<span lang="EN-US">mod m</span>)为<span lang="EN-US">x;</span>现求<span lang="EN-US">x</span>能达到的最小值及该情况下<span lang="EN-US">k</span>的最小值,以及<span lang="EN-US">x</span>能达到的最大值及该情况下的<span lang="EN-US">k</span>的最小值<span lang="EN-US">(</span>可以存在<span lang="EN-US">x</span>的最小值与最大值相同的情况<span lang="EN-US">)</span>。小<span lang="EN-US">FF</span>还知道,如果他找到了正确的答案,那么就可以通往神庙的下层了。但这个问题似乎不太好解决,小<span lang="EN-US">FF</span>就找到了你,并答应找到财宝以后和你二八分(当然你拿二……)。</p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0"></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0"><span lang="EN-US" style="font-size:16.0pt"><o:p></o:p></span></p> </p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0"><span lang="EN-US"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal"></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0"><span style="font-family: 宋体; font-size: 16pt;"></span><b style="font-family: 宋体; font-size: 16pt;">输入格式</b><span style="font-family: 宋体; font-size: 16pt;"></span></p> <p class="MsoNormal" style="text-indent:15.75pt;mso-char-indent-count:1.5"><span style="mso-bidi-font-size:10.5pt;font-family:宋体;mso-ascii-font-family:"Times New Roman"; mso-hansi-font-family:"Times New Roman"">第一行为数串,且数串中不存在</span><span lang="EN-US">0</span><span style="mso-bidi-font-size:10.5pt; font-family:宋体;mso-ascii-font-family:"Times New Roman";mso-hansi-font-family: "Times New Roman""></span><span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0"></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0"><span lang="EN-US" style="font-size:16.0pt"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal"><span style="font-size: 16pt;"><b>输出格式</b></span><span lang="EN-US" style="font-size:16.0pt"><o:p></o:p></span></p> <p class="MsoNormal" style="text-indent:15.75pt;mso-char-indent-count:1.5">四个数,分别为<span lang="EN-US">x</span>的最小值和该情况下的<span lang="EN-US">k</span>,以及<span lang="EN-US">x</span>的最大值和该情况下的<span lang="EN-US">k</span>,相邻两个数之间用以个空格隔开。</p> <p class="MsoNormal" style="text-indent:15.75pt;mso-char-indent-count:1.5"><span lang="EN-US"><o:p></o:p></span></p> <p></p>

【输入样例】 4421 22

【输出样例】 0 1 21 0 【数据范围】 对于30%的数据:2≤字符串的长度L≤50。 对于100%的数据:2≤字符串的长度L≤10002≤m≤50

0

 

 

2017-04-16 09:21:56

1

128

N

0

2

0

1672

2010NOI导刊_02】最接近神的人(sophist/pas/c/cpp

<p class="MsoNormal"><b><span style="font-size: 15pt;">【题目描述】</span></b><b><span lang="EN-US" style="font-size:15.0pt"><o:p></o:p></span></b></p> <p class="MsoNormal" style="text-indent:15.75pt;mso-char-indent-count:1.5">破解了符文之语,小<span lang="EN-US">FF</span>开启了通往地下的道路。当他走到最底层时,发现正前方有一扇巨石门,门上雕刻着一幅古代人进行某种活动的图案。而石门上方用古代文写着神的殿堂。小<span lang="EN-US">FF</span>猜想里面应该就有王室的遗产了。但现在的问题是如何打开这扇门……<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal" style="text-indent:15.75pt;mso-char-indent-count:1.5">仔细研究后,他发现门上的图案大概是说:古代人认为只有智者才是最容易接近神明的。<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal">而最聪明的人往往通过一种仪式选拔出来。仪式大概是指,即将隐退的智者为他的候选人写下一串无序的数字,并让他们进行一种操作,即交换序列中相邻的两个元素。而用最少的交换次数使原序列变成不下降序列的人即是下一任智者。<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US">   </span><span lang="EN-US">FF</span>发现门上同样有着<span lang="EN-US">n</span>个数字。于是他认为打开这扇门的秘诀就是找到让这个序列变成不下降序列所需要的最小次数。但小<span lang="EN-US">FF</span>不会……只好又找到了你,并答应事成之后与你三七分……<span lang="EN-US"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal"><b><span style="font-size: 16pt;">【输入格式】</span></b><b><span lang="EN-US" style="font-size:16.0pt"><o:p></o:p></span></b></p> <p class="MsoNormal" style="text-indent:15.75pt;mso-char-indent-count:1.5">第一行为一个整数<span lang="EN-US">n</span>,表示序列长度<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal" style="text-indent:15.75pt;mso-char-indent-count:1.5">第二行为<span lang="EN-US">n</span>个整数,表示序列中每个元素。</p> <p class="MsoNormal" style="text-indent:15.75pt;mso-char-indent-count:1.5"></p> <p class="MsoNormal" style="text-indent:15.75pt;mso-char-indent-count:1.5"><span lang="EN-US"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal"><span style="font-size: 16pt;"><b>输出格式】</b></span><b><span lang="EN-US" style="font-size:16.0pt"><o:p></o:p></span></b></p> <p class="MsoNormal" style="text-indent:15.75pt;mso-char-indent-count:1.5">一个整数<span lang="EN-US">ans</span>,即最少操作次数。<span lang="EN-US"><o:p></o:p></span></p> <p></p>

【输入样例】 4 2 8 0 3

【输出样例】 3 样例说明:开始序列为2 8 0 3,目标序列为0 2 3 8,可进行三次操作的目标序列: 1. Swap(8,0)2 0 8 3 2. Swap (2,0)0 2 8 3 3. Swap (8,3)0 2 3 8 【数据范围】 对于30%的数据1≤n≤104。 对于100%的数据 1≤n≤5*105

0

 

 

2017-04-16 09:21:56

1

128

N

0

2

0

1673

2010NOI导刊_02】古代人的难题(puzzle.pas/c/cpp

<p class="MsoNormal"><b><span style="font-size: 16pt;">【题目描述】</span></b><b><span lang="EN-US" style="font-size:16.0pt"><o:p></o:p></span></b></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0">门打开了,里面果然是个很大的厅堂。但可惜厅堂内除了中央的一张羊皮纸和一支精致的石笔,周围几具骷髅外什么也没有。难得这就是王室是遗产?小<span lang="EN-US">FF</span>不信,他仔细阅读了羊皮纸上的内容后发现,里面书写的古代人一直没能解出的难题,解除这道题目的人只要将答案用石笔写到这张羊皮纸上就能到达王室的宝藏室了。而当小<span lang="EN-US">FF</span>拿起石笔后,刚刚打开的巨石门突然关上了。这是小<span lang="EN-US">FF</span>意识到原来那几具骷髅是在他之前到这里的冒险者,恐怕是因为没能破解这道题而困死在这里了。小<span lang="EN-US">FF</span>越想越害怕,急忙联系到了你,为了能保命,他甚至愿意和你五五分……看来你不得不再次帮他了。羊皮纸上的问题如下:已知<span lang="EN-US">x</span><span lang="EN-US">y</span>为整数,且满足以下两个条件:<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal" style="margin-left:39.0pt;text-indent:-18.0pt;mso-list:l0 level1 lfo1"><!--[if !supportLists]--><span lang="EN-US">1<span style="font-size: 7pt; font-family: 'Times New Roman';">  </span></span><!--[endif]--><span lang="EN-US">x</span><span lang="EN-US">y</span>∈<span lang="EN-US">[1</span>…<span lang="EN-US">k]</span>,且<span lang="EN-US">x</span><span lang="EN-US">y</span><span lang="EN-US">k</span>∈<span lang="EN-US">Z<o:p></o:p></span></p> <p class="MsoNormal" style="margin-left:39.0pt;text-indent:-18.0pt;mso-list:l0 level1 lfo1"><!--[if !supportLists]--><span lang="EN-US">2<span style="font-size: 7pt; font-family: 'Times New Roman';">  </span></span><!--[endif]--><span lang="EN-US">(x^2-xy-y^2)^2=1<o:p></o:p></span></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0">给你一个整数<span lang="EN-US">k</span>,求一组满足上述条件的<span lang="EN-US">x</span><span lang="EN-US">y</span>并且使得<span lang="EN-US">x^2+y^2</span>的值最大。<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0">当小<span lang="EN-US">FF</span>得到答案后,用石笔将答案书写在羊皮纸上,那么就能到达王室的遗产所在地了。<span lang="EN-US"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal"><span style="font-size: 16pt;"><b>输入格式</b></span><span lang="EN-US" style="font-size:16.0pt"><o:p></o:p></span></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0">一个整数<span lang="EN-US">k<o:p></o:p></span></p> <p></p>

<p class="MsoNormal"><span style="font-size: 16pt;"><b>输出格式</b></span><b><span lang="EN-US" style="font-size:16.0pt"><o:p></o:p></span></b></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0">输出文件仅一行,两个整数;两个整数分别表示<span lang="EN-US">x</span><span lang="EN-US">y</span><span lang="EN-US">x</span><span lang="EN-US">y</span>之间用一个空格隔开。<span lang="EN-US"><o:p></o:p></span></p> <p></p>

【输入样例】 1995

【输出样例】 1597 987 【数据范围】 对于30%的数据:2≤k≤104 对于100%的数据:2≤k≤1018

0

 

 

2017-04-16 09:21:56

1

128

N

0

2

0

1674

2010NOI导刊_02】宝物筛选(Treasure.pas/c/cpp)

<p class="MsoNormal"><span style="font-size: 16pt;"><b>题目描述</b></span><span lang="EN-US" style="font-size:16.0pt"><o:p></o:p></span></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0">终于,破解了千年的难题。小<span lang="EN-US">FF</span>找到了王室的宝物室,里面堆满了无数价值连城的宝物……这下小<span lang="EN-US">FF</span>可发财了,嘎嘎。但是这里的宝物实在是太多了,小<span lang="EN-US">FF</span>的采集车似乎装不下那么多宝物。看来小<span lang="EN-US">FF</span>只能含泪舍弃其中的一部分宝物了……<span lang="EN-US">FF</span>对洞穴里的宝物进行了整理,他发现每样宝物都有一件或者多件,他粗略的估算了下每样宝物的价值,之后开始了宝物筛选工作:小<span lang="EN-US">FF</span>有一个最大载重为<span lang="EN-US">W</span>的采集车,洞穴里总共有<span lang="EN-US">n</span>种宝物,每种宝物的价值为<span lang="EN-US">v[i]</span>,重量为<span lang="EN-US">w[i]</span>,每种宝物有<span lang="EN-US">m[i]</span>件。小<span lang="EN-US">FF</span>希望在采集车不超载的前提下,选择一些宝物装进采集车,使得它们的价值和最大。<span lang="EN-US"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal"><span style="font-size: 16pt;"><b>输入格式</b></span><span lang="EN-US" style="font-size:16.0pt"><o:p></o:p></span></p> <p class="MsoNormal">第一行为一个整数<span lang="EN-US">N</span><span lang="EN-US">W</span>,分别表示宝物种数和采集车的最大载重。<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal">接下来<span lang="EN-US">n</span>行每行三个整数,其中第<span lang="EN-US">i</span>行第一个数表示第<span lang="EN-US">i</span>类品价值,第二个整数表示一件该类物品的重量,第三个整数为该类物品数量。<span lang="EN-US"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal"><span style="font-size: 16pt;"><b>输出格式</b></span><span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal">输出仅一个整数<span lang="EN-US">ans</span>,表示在采集车不超载的情况下收集的宝物的最大价值。<span lang="EN-US"><o:p></o:p></span></p> <p></p>

【输入样例】 4 20 3 9 3 5 9 1 9 4 2 8 1 3

【输出样例】 47 【数据范围】 对于30%的数据:n≤∑m[i]≤10^4; 0≤W≤10^3 对于100%的数据:n≤∑m[i]≤10^50≤W≤4*10^4; 1≤n≤100.

0

 

 

2017-04-16 09:21:56

1

128

N

0

2

0

1675

2010NOI导刊_03】帮助Bubu

<p class="MsoNormal"><b><span style="font-size: 16pt;">题目</span></b><b><span lang="EN-US" style="font-size:16.0pt"><o:p></o:p></span></b></p> <table class="MsoNormalTable" border="1" cellspacing="0" cellpadding="0" style="border-collapse:collapse;border:none;mso-border-alt:solid windowtext .5pt; mso-yfti-tbllook:480;mso-padding-alt:0cm 5.4pt 0cm 5.4pt;mso-border-insideh: .5pt solid windowtext;mso-border-insidev:.5pt solid windowtext"> <tbody> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">题目<span lang="EN-US"><o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-left:none;mso-border-left-alt:solid windowtext .5pt;mso-border-alt: solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">帮助<span lang="EN-US">BUBU<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-left:none;mso-border-left-alt:solid windowtext .5pt;mso-border-alt: solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">万圣节后的早餐<span lang="EN-US"><o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border:solid windowtext 1.0pt; border-left:none;mso-border-left-alt:solid windowtext .5pt;mso-border-alt: solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">魔鬼杀手<span lang="EN-US"><o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border:solid windowtext 1.0pt; border-left:none;mso-border-left-alt:solid windowtext .5pt;mso-border-alt: solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">染色的立方体<span lang="EN-US"><o:p></o:p></span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">文件名<span lang="EN-US"><o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">p1<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">p2<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">p3<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">p4<o:p></o:p></span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">扩展名<span lang="EN-US"><o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">.pas/.c/.cpp<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">.pas/.c/.cpp<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">.pas/.c/.cpp<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">.pas/.c/.cpp<o:p></o:p></span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">输入文件<span lang="EN-US"><o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">in.txt<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">in.txt<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">in.txt<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">in.txt<o:p></o:p></span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">输出文件<span lang="EN-US"><o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">out.txt<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">out.txt<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">out.txt<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">out.txt<o:p></o:p></span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">时间限制<span lang="EN-US"><o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">3s<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">10s<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">1s<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">2s<o:p></o:p></span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">空间限制<span lang="EN-US"><o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">32768k<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">65536k<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">32768k<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">32768k<o:p></o:p></span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">满分<span lang="EN-US"><o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">100<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">100<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">100<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">100<o:p></o:p></span></p> </td> </tr> <tr> <td width="114" valign="top" style="width:85.2pt;border:solid windowtext 1.0pt; border-top:none;mso-border-top-alt:solid windowtext .5pt;mso-border-alt:solid windowtext .5pt; padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal">附加文件<span lang="EN-US"><o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">N/A<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.2pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">N/A<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">N/A<o:p></o:p></span></p> </td> <td width="114" valign="top" style="width:85.25pt;border-top:none;border-left: none;border-bottom:solid windowtext 1.0pt;border-right:solid windowtext 1.0pt; mso-border-top-alt:solid windowtext .5pt;mso-border-left-alt:solid windowtext .5pt; mso-border-alt:solid windowtext .5pt;padding:0cm 5.4pt 0cm 5.4pt"> <p class="MsoNormal"><span lang="EN-US">N/A<o:p></o:p></span></p> </td> </tr> </tbody> </table> <p class="MsoNormal"><span lang="EN-US"> </span></p> <p class="MsoNormal" style="margin-left:18.0pt;text-indent:-18.0pt;mso-list:l0 level1 lfo1; tab-stops:list 18.0pt"><!--[if !supportLists]--><b><span lang="EN-US" style="font-size:16.0pt;mso-fareast-font-family:"Times New Roman"">1.<span style="font-weight: normal; font-size: 7pt; font-family: 'Times New Roman';">    </span></span></b><!--[endif]--><b><span style="font-size: 16pt;">帮助</span></b><b><span lang="EN-US" style="font-size:16.0pt">Bubu<o:p></o:p></span></b></p> <p class="MsoNormal"><span lang="EN-US">Bubu</span>的书架乱成一团了!帮他一下吧!<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal">他的书架上一共有<span lang="EN-US">n</span>本书。我们定义混乱值是连续相同高度书本的段数。例如,如果书的高度是<span lang="EN-US">30,30,31,32</span>,那么混乱值为<span lang="EN-US">3,30,32,32,31</span>的混乱度也是<span lang="EN-US">3</span>,但<span lang="EN-US">31,32,31,32,31</span>的混乱度是<span lang="EN-US">5-</span>,这实在是太乱了。<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US">Bubu</span>想尽可能地减少混乱度,但他有点累了,所以他决定最多取出<span lang="EN-US">K</span>本书,再随意将他们放到书架上。你能帮助他吗?<span lang="EN-US"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal">最多会有<span lang="EN-US">20</span>组测试数据。每组测试数据开头为两个整数<span lang="EN-US">n, k(1</span>≤<span lang="EN-US">k</span>≤<span lang="EN-US">n</span>≤<span lang="EN-US">100)</span>,表示总共有<span lang="EN-US">n</span>本书,最多可以进行<span lang="EN-US">k</span>次搬书操作。接下来一行有<span lang="EN-US">n</span>个整数,表示每本书的高度,从左到右。每本书的高度是<span lang="EN-US">25</span><span lang="EN-US">32</span>之间的整数。最后一组数据后有一行<span lang="EN-US">n=k=0</span></p> <p class="MsoNormal"></p> <p class="MsoNormal"><span lang="EN-US"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal">对于每一组数据,输出<span lang="EN-US">case</span>标号和最终最小的混乱度。在每组数据后打印一个空行。</p> <p class="MsoNormal"></p> <p class="MsoNormal"><span lang="EN-US"><o:p></o:p></span></p> <p></p>

5 2 25 25 32 32 25 5 1 25 26 25 26 25 0 0

Case 1:2 Case 2:3

0

 

 

2017-04-16 09:21:56

1

128

N

1

2

0

1676

2010NOI导刊_03】万圣节后的早晨

<p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0">要求你写一个程序,在一个地图中,找到最小步数将每个鬼移动到他们指定的位置。地图包含一些小方格。每格要么是墙(鬼不能进入),要么是走廊(鬼能进入)。<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0">每一步里,你可以同时移动任意数量的鬼。每个鬼要么待在原地不动,要么移动到相邻的格子里(相邻的格子有公共边),如果移动满足下列条件,则移动是可行的。<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal" style="margin-left:0cm;text-indent:21.0pt;mso-char-indent-count: 2.0;mso-list:l0 level1 lfo1;tab-stops:list 18.0pt"><!--[if !supportLists]--><span lang="EN-US">1.<span style="font-size: 7pt; font-family: 'Times New Roman';">         </span></span><!--[endif]-->没有一个以上的鬼在同一个格子里。<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal" style="margin-left:0cm;text-indent:21.0pt;mso-char-indent-count: 2.0;mso-list:l0 level1 lfo1;tab-stops:list 18.0pt"><!--[if !supportLists]--><span lang="EN-US">2.<span style="font-size: 7pt; font-family: 'Times New Roman';">         </span></span><!--[endif]-->没有一对鬼在一步里交换了位置。<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal" style="text-indent:21.0pt;mso-char-indent-count:2.0">例如,假设鬼的位置是如右上图所示的,其中<span lang="EN-US">sharp(#)</span>表示墙,空格表示走廊,<span lang="EN-US">a</span><span lang="EN-US">b</span><span lang="EN-US">c</span>表示鬼:<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:14.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">####<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:14.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体"> ab#<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:14.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#c##<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:14.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">####<o:p></o:p></span></p> <p class="MsoNormal">经过一步移动过后,地图可以变成如下的样子:<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:14.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">####    ####   ####   ####<o:p></o:p></span></p> <p class="MsoNormal" style="text-indent:7.0pt;mso-char-indent-count:.5"><span lang="EN-US" style="font-size:14.0pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">ab#    a  b#   acb#   ab #<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:14.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#c##    #c##   # ##    #c##<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:14.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">####    ####   ####   ####<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US">Input:<o:p></o:p></span></p> <p class="MsoNormal">输入包括最多<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">10</span>组数据,每组数据包含一幅地图。输入格式如下:<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="mso-bidi-font-size:10.5pt; font-family:Gungsuh;mso-fareast-font-family:宋体"><!--[if gte vml 1]><v:shapetype id="_x0000_t75" coordsize="21600,21600" o:spt="75" o:preferrelative="t" path="m@4@5l@4@11@9@11@9@5xe" filled="f" stroked="f"> <v:stroke joinstyle="miter"/> <v:formulas> <v:f eqn="if lineDrawn pixelLineWidth 0"/> <v:f eqn="sum @0 1 0"/> <v:f eqn="sum 0 0 @1"/> <v:f eqn="prod @2 1 2"/> <v:f eqn="prod @3 21600 pixelWidth"/> <v:f eqn="prod @3 21600 pixelHeight"/> <v:f eqn="sum @0 0 1"/> <v:f eqn="prod @6 1 2"/> <v:f eqn="prod @7 21600 pixelWidth"/> <v:f eqn="sum @8 21600 0"/> <v:f eqn="prod @7 21600 pixelHeight"/> <v:f eqn="sum @10 21600 0"/> </v:formulas> <v:path o:extrusionok="f" gradientshapeok="t" o:connecttype="rect"/> <o:lock v:ext="edit" aspectratio="t"/> </v:shapetype><v:shape id="_x0000_i1025" type="#_x0000_t75" style='width:104.25pt; height:93.75pt'> <v:imagedata src="file:///C:\DOCUME~1\ADMINI~3.LZ-\LOCALS~1\Temp\msohtml1\09\clip_image001.png" o:title=""/> </v:shape><![endif]--><!--[if !vml]--><img width="139" height="125" src="http://10.208.83.181:80/JudgeOnline/admin/../file:///C:/DOCUME~1/ADMINI~3.LZ-/LOCALS~1/Temp/msohtml1/09/clip_image002.jpg" v:shapes="_x0000_i1025" alt="" /><!--[endif]--><o:p></o:p></span></p> <p class="MsoNormal">第一行的<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">w</span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">h</span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">n</span>表示地图的宽度和高度,<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">n</span>表示鬼的数目,他们满足:<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="mso-bidi-font-size:10.5pt; font-family:Gungsuh;mso-fareast-font-family:宋体">4</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">w</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">16, 4</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">h</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">16, 1</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">n</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">3<o:p></o:p></span></p> <p class="MsoNormal">接下来<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">h</span>行,每行<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">w</span>个字符:<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal">一个<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">#</span>表示墙。<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal">一个小写字母表示鬼的初始位置(该位置也是走廊)。<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal">一个大写字母表示鬼的目标位置(该位置也是走廊)。<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal">一个空格表示空的走廊。<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal">在每幅地图里,前<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">n</span>个小写字母和前<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">n</span>个大写字母表示鬼的初始位置及鬼的目标位置。我们需要将小写字母表示的鬼移动到对应的大写字母的位置里。<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal">最后一组数据后一行有三个<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">0</span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US">Output</span><span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal">对每组数据输出一行一个整数,表示最小的移动步数。<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal" style="margin-left:18.0pt;text-indent:-18.0pt;mso-list:l0 level1 lfo1"><!--[if !supportLists]--><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh;mso-bidi-font-family: Gungsuh">5<span style="font-size: 7pt; font-family: 'Times New Roman';">       </span></span><!--[endif]--><span lang="EN-US" style="font-size:16.0pt; font-family:Gungsuh;mso-fareast-font-family:宋体">5</span><span lang="EN-US" style="font-size:12.0pt;font-family:Gungsuh;mso-fareast-font-family:宋体"> </span><span lang="EN-US" style="font-size:5.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"> </span><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh;mso-fareast-font-family:宋体">2<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#####<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#A#B#<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#    #<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#b#a#<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#####<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">16</span><span lang="EN-US" style="font-size:6.5pt; font-family:Gungsuh;mso-fareast-font-family:宋体">  </span><span lang="EN-US" style="font-size:16.0pt; font-family:Gungsuh;mso-fareast-font-family:宋体">4</span><span lang="EN-US" style="font-size:26.0pt;font-family:Gungsuh;mso-fareast-font-family:宋体"> </span><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">3<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">################<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">##</span><span lang="EN-US" style="font-size:36.0pt; font-family:Gungsuh;mso-fareast-font-family:宋体"> </span><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh;mso-fareast-font-family:宋体">##########</span><span lang="EN-US" style="font-size:36.0pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"> </span><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">##<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#     ABCcba  </span><span lang="EN-US" style="font-size:26.0pt;font-family:Gungsuh;mso-fareast-font-family:宋体"> </span><span lang="EN-US" style="font-size:16.0pt; font-family:Gungsuh;mso-fareast-font-family:宋体">#<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">################<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">16 16 3<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">################<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">###  ##     #   ##<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">##   #   ##   #</span><span lang="EN-US" style="font-size:36.0pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"> </span><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">c#<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#  ##  ########b#<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体"># ##   # #     #  #<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#  # ##    #  # ##<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">## </span><span lang="EN-US" style="font-size:6.5pt; font-family:Gungsuh;mso-fareast-font-family:宋体"> </span><span lang="EN-US" style="font-size:16.0pt; font-family:Gungsuh;mso-fareast-font-family:宋体">a#  #  #  #  #<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">### ## #### ## #<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">##   #   #  #  #<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#  ##### # ## ##<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">####   #B# #   #<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">##  C#   #   ###<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#  # # ####### #<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体"># ######  A##  #<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">#        #     ##<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">###############<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">0 0 0<o:p></o:p></span></p> <p></p>

<p class="MsoNormal"><span lang="EN-US" style="font-size:14.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">7<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:14.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">36<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:14.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">77<o:p></o:p></span></p> <p></p>

 

 

0

 

 

2017-04-16 09:21:56

1

128

N

2

2

0

1677

2010NOI导刊_03】魔鬼杀手

<p class="MsoNormal">你生活在一个怪兽的世界里。你需要用魔法反抗这些怪兽。<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal">每个怪兽都有一定的<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">hit points</span>,表示他们的生命值。你可以靠施魔法,降低怪兽的<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">hit points</span>。每个魔法都会有一定的<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">damage</span>,表示会减少被攻击者<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">damage</span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">hit point</span>。一个怪兽被击败了当前仅当它的<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">hit point</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">0</span>。另一方面,魔法是需要消耗魔力的。因为你的魔力是有限的,你希望用最少的魔力击败所有的怪兽。写一个程序完成这个任务。<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal">输入按如下格式给出:<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">N<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">HP</span><span lang="EN-US" style="mso-bidi-font-size: 10.5pt;font-family:Gungsuh;mso-fareast-font-family:宋体">1<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">HP</span><span lang="EN-US" style="mso-bidi-font-size: 10.5pt;font-family:Gungsuh;mso-fareast-font-family:宋体">2<o:p></o:p></span></p> <p class="MsoNormal"><span style="font-size: 16pt;">……</span><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh;mso-fareast-font-family:宋体"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">HP</span><span lang="EN-US" style="mso-bidi-font-size: 10.5pt;font-family:Gungsuh;mso-fareast-font-family:宋体">N<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">M<o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">Name</span><sub><span lang="EN-US" style="mso-bidi-font-size: 10.5pt;font-family:Gungsuh;mso-fareast-font-family:宋体">1</span></sub><sub><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">  </span></sub><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh;mso-fareast-font-family:宋体">MP<sub>1</sub></span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">  </span><span lang="EN-US" style="font-size:15.0pt;font-family:Gungsuh;mso-fareast-font-family:宋体">Target</span><sub><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">1</span></sub><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">  Damage<sub>1</sub></span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">Name<sub>2</sub></span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">  </span><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh;mso-fareast-font-family:宋体">MP<sub>2</sub></span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">  </span><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh;mso-fareast-font-family:宋体">Target<sub>2 </sub> Damage<sub>2</sub></span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal"><span style="font-size: 16pt;">……</span><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh;mso-fareast-font-family:宋体"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh; mso-fareast-font-family:宋体">Name<sub>M</sub></span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">  </span><span lang="EN-US" style="font-size:16.0pt;font-family:Gungsuh;mso-fareast-font-family:宋体">MP<sub>M  </sub>Target<sub>M</sub>  Damage<sub>M</sub></span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US" style="mso-bidi-font-size:10.5pt; font-family:Gungsuh;mso-fareast-font-family:宋体"> </span></p> <p class="MsoNormal"><span lang="EN-US" style="mso-bidi-font-size:10.5pt; font-family:Gungsuh;mso-fareast-font-family:宋体">N</span>是怪兽的数量(<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">1</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">N</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">100</span>),<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">HPi</span>表示第<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">i</span>个怪兽的<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">hit point</span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">1</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">Hpi</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">100000</span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">,M</span>表示可用的魔法数量(<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">1</span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">=M</span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">=100</span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">,Namej</span>是第<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">j</span>种魔法的名字,最长会有<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">30</span>个大写或小写字母,<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">MPj</span>是这种魔法需要消耗的魔力(<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">0</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">MPj</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">99</span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">,Targetj</span>要么是“<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">Single</span>”,要么是“<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">All</span>”,表示该魔法只攻击单个怪兽或是对全体怪兽同时有效。<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">Damagej</span>表示对于所有攻击对象,可以减少攻击对象<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">Damagej</span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">hit point</span><span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">0</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">Damagej</span>≤<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">999999</span>)。<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p class="MsoNormal">所有数字都是整数。最少有一种魔法的<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体">Damage</span>是非零的。<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal">输出一行,包含一个整数,表示最小需要消耗的魔力。<span lang="EN-US" style="mso-bidi-font-size:10.5pt;font-family:Gungsuh;mso-fareast-font-family: 宋体"><o:p></o:p></span></p> <p></p>

3 8000 15000 30000 3 Flare 45 single 8000 Meteor 62 All 6000 Ultimate 80 All 9999

232

0

 

 

2017-04-16 09:21:56

1

128

N

1

2

0

1678

2010NOI导刊_03】染色的立方体

<p class="MsoNormal">小胖最近迷上了<span lang="EN-US">3D</span>物体,尤其是立方体。他手里有很多个立方体,他想让所有的立方体全都长得一样,所以他决定给某些立方体的表面重涂颜色,使得所有的立方体完全相同。但是小胖是很懒的,他想知道最少涂多少次颜色,可以让所有立方体完全相同。<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal"></p> <p class="MsoNormal" align="center" style="text-align:center"><span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal"></p> <p class="MsoNormal"><img src="http://10.208.83.181:80/upload/201307/2010NOI导刊_03】染色的立方体1.jpg" width="0" height="0" alt="" /></p> <p class="MsoNormal"><span lang="EN-US"><o:p></o:p></span></p> <p></p>

<p class="MsoNormal"><span lang="EN-US">Input</span><span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal">输入包含多组数据,每组数据第一行<span lang="EN-US">n(1</span>≤<span lang="EN-US">n</span>≤<span lang="EN-US">4)</span>,表示立方体的数量,接下来<span lang="EN-US">n</span>行,每行<span lang="EN-US">6</span>个字符串,表示立方体<span lang="EN-US">6</span>个面的颜色。<span lang="EN-US"><o:p></o:p></span></p> <p class="MsoNormal"><span lang="EN-US">Color1 Color2 Color3 Color4 Color5 Color6<o:p></o:p></span></p> <p class="MsoNormal">其中,面的标号如下:<a href="http://localhost/upload/201307/file/%E3%80%902010NOI%E5%AF%BC%E5%88%8A_03%E3%80%91%E6%9F%93%E8%89%B2%E7%9A%84%E7%AB%8B%E6%96%B9%E4%BD%93/%E3%80%902010NOI%E5%AF%BC%E5%88%8A_03%E3%80%91%E6%9F%93%E8%89%B2%E7%9A%84%E7%AB%8B%E6%96%B9%E4%BD%931.jpg"><img src="http://localhost/upload/201307/file/%E3%80%902010NOI%E5%AF%BC%E5%88%8A_03%E3%80%91%E6%9F%93%E8%89%B2%E7%9A%84%E7%AB%8B%E6%96%B9%E4%BD%93/%E3%80%902010NOI%E5%AF%BC%E5%88%8A_03%E3%80%91%E6%9F%93%E8%89%B2%E7%9A%84%E7%AB%8B%E6%96%B9%E4%BD%931.jpg" alt="" /></a></p> <p class="MsoNormal"><img src="http://localhost/upload/201307/%E3%80%902010NOI%E5%AF%BC%E5%88%8A_03%E3%80%91%E6%9F%93%E8%89%B2%E7%9A%84%E7%AB%8B%E6%96%B9%E4%BD%932.jpg" width="602" height="817" alt="" /></p> <p class="MsoNormal"></p> <p class="MsoNormal"><span style="text-align: center;">Figure4:An example of recoloring</span></p> <p></p>

<p class="MsoNormal">每组数据输出一行一个整数,表示最小的涂色数。(涂一个面算一个涂色)<span lang="EN-US"><o:p></o:p></span></p> <p></p>

3 scareIet green blue yellow magenta cyan blue pink green magenta cyan lemon purple red blue yellow cyan green 2 red green blue yellow magenta cyan cyan green blue yellow magenta red 2 red green gray gray magenta cyan cyan green gray gray magenta red 2 red green blue yellow magenta cyan magenta red blue yellow cyan green 3 red green blue yellow magenta cyan cyan green blue yellow magenta red magenta red blue yellow cyan green 3 blue green green green green blue green blue blue green green green green green green green green sea-green 3 red yellow red yellow red yellow red red yellow yellow red yellow red red red red red red 4 violet violet salmon salmon salmon salmon violet salmon salmon salmon salmon violet violet violet salmon salmon violet violet violet violet violet violet salmon salmon 1 red green blue yellow magenta cyan 4 magenta pink red scarlet vermilion wine-red aquamarine blue cyan indigo sky-blue turquoise-blue blond cream chrome-yellow lemon olive yellow chrome-green emerald-green green olive vilidian sky-blue 0

4 2 0 0 2 3 4 4 0 16

0

 

 

2017-04-16 09:21:56

1

128

N

0

1

0

1679

2010NOI导刊_04】报数(Read.pas/c/cpp

<div><b><span style="font-size: 24pt"> </span></b> <table cellspacing="0" cellpadding="0" border="1" style="border-right: medium none; border-top: medium none; border-left: medium none; border-bottom: medium none; border-collapse: collapse"> <tbody> <tr> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: windowtext 1pt solid; padding-left: 5.4pt; padding-bottom: 0cm; border-left: windowtext 1pt solid; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>题目名称</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: windowtext 1pt solid; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>报数</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: windowtext 1pt solid; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>跑步</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: windowtext 1pt solid; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.25pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>装备运输</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: windowtext 1pt solid; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.25pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>方程的解</b></div> </td> </tr> <tr> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: windowtext 1pt solid; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>文件名</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>Read</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>Runing</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.25pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>Transport</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.25pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>Equation</b></div> </td> </tr> <tr> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: windowtext 1pt solid; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>输入文件名</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>Read.in</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>Runing.in</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.25pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>Transport.in</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.25pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>Equation.in</b></div> </td> </tr> <tr> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: windowtext 1pt solid; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>输出文件名</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>Read.out</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>Runing.out</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.25pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>Transport.out</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.25pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>Equation.out</b></div> </td> </tr> <tr> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: windowtext 1pt solid; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>时间限制</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>1s</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>1s</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.25pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>1s</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.25pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>1s</b></div> </td> </tr> <tr> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: windowtext 1pt solid; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>空间限制</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>64M</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.2pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>64M</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.25pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>64M</b></div> </td> <td valign="top" width="114" style="border-right: windowtext 1pt solid; padding-right: 5.4pt; border-top: #d4d0c8; padding-left: 5.4pt; padding-bottom: 0cm; border-left: #d4d0c8; width: 85.25pt; padding-top: 0cm; border-bottom: windowtext 1pt solid; background-color: transparent"> <div><b>64M</b></div> </td> </tr> </tbody> </table> </div> <div style="text-indent: 21.1pt"><b>【题目描述】</b></div> <div style="margin: 0cm 0cm 0pt 18pt">CG同学又弄到一批新牛,新牛到了农场后,首先学习汉语,数的朗读成为新牛的难题。朗读绝对值小于10亿的数。</div> <div style="margin: 0cm 0cm 0pt 18pt"><span>       </span>新牛们知道汉语中有如下的朗读规则:</div> <div style="margin: 0cm 0cm 0pt 73.5pt; text-indent: -18pt"><span>1.<span style="font: 7pt 'Times New Roman'">       </span></span>首先读符号位,然后读整数部分。整数部分之后可能出现小数点,如果有小数部分则小数点一定出现,并且读出小数点之后读小数部分。</div> <div style="margin: 0cm 0cm 0pt 73.5pt; text-indent: -18pt"><span>2.<span style="font: 7pt 'Times New Roman'">       </span></span>符号位的读法是:</div> <div style="margin: 0cm 0cm 0pt 112.5pt; text-indent: -36pt"><span>1<span style="font: 7pt 'Times New Roman'">       </span></span>正数,不论正号“+”是否出现,都不必读出符号位;</div> <div style="margin: 0cm 0cm 0pt 112.5pt; text-indent: -36pt"><span>2<span style="font: 7pt 'Times New Roman'">       </span></span>负数最左边的符号是“-”读成”(“F”来表示”)</div> <div style="margin: 0cm 0cm 0pt 73.5pt; text-indent: -18pt"><span>3.<span style="font: 7pt 'Times New Roman'">       </span></span>整数部分的读法是:</div> <div style="margin: 0cm 0cm 0pt 115.5pt; text-indent: -18pt"><span>(1)<span style="font: 7pt 'Times New Roman'">    </span></span>如果整数部分不存在或整数部分全为零则直接读成(以“0”来表示);</div> <div style="margin: 0cm 0cm 0pt 115.5pt; text-indent: -18pt"><span>(2)<span style="font: 7pt 'Times New Roman'">    </span></span>否则从整数部分中最左边的非零数字开始读起,然后以十,百,千,万,亿(分别以“S”,“B”,“Q”“W”,“Y”来表示)等数量单位来拼读整数部分。</div> <div style="margin: 0cm 0cm 0pt 73.5pt; text-indent: -18pt"><span>4.<span style="font: 7pt 'Times New Roman'">       </span></span>整数部分中:</div> <div style="margin: 0cm 0cm 0pt 112.5pt; text-indent: -36pt"><span>1<span style="font: 7pt 'Times New Roman'">       </span></span>每一个非零数字都必须结合各个相应的数量单位读出来。</div> <div style="margin: 0cm 0cm 0pt 112.5pt; text-indent: -36pt"><span>2<span style="font: 7pt 'Times New Roman'">       </span></span>每一段连续的只能读成一个,但是某一段连续的的左侧或者右侧不存在非零数字(这里只考虑整数部分)则这一段不应该读出来。</div> <div style="margin: 0cm 0cm 0pt 73.5pt; text-indent: -18pt"><span>5.<span style="font: 7pt 'Times New Roman'">       </span></span>如果有小数部分,则首先读(以“D”来表示),然后从左至右有顺序的读出各个小数位。在读小数部分的时候不可以使用十,百,千,万,亿等数量单位;但是小数部分的每一个数字都要读出来,连续的零不可以读成一个零,而应该分别读出。</div> <div style="margin: 0cm 0cm 0pt 73.5pt; text-indent: -18pt"><span>6.<span style="font: 7pt 'Times New Roman'">       </span></span>如果数中有小数点而没有小数部分,则不应该把小数点读出来。</div> <div style="margin: 0cm 0cm 0pt 73.5pt"><span>      </span>例如,</div> <div style="margin: 0cm 0cm 0pt 73.5pt">—0020030004.567应该读成“F2Q03W04D567”000.89应该读成“0D89”</div> <div style="margin: 0cm 0cm 0pt 73.5pt">请你编写程序帮助新牛把给定的数正确地读出来。</div>

<div style="text-indent: 21.1pt"><b>【输入数据】</b></div> <div style="margin: 0cm 0cm 0pt 73.5pt">输入文件仅一行,存放了一个数(不超过50个字符),其绝对值小于10亿。</div>

<div style="text-indent: 21.1pt"><b>【输出数据】</b></div> <div style="margin: 0cm 0cm 0pt 73.5pt">输出文件仅一行,输出这个数的正确读法。</div>

【样例输入】 —0020030004.567

【样例输出】 F2Q03W04D567

0

 

 

2017-04-16 09:21:56

1

128

N

0

0

0

1680

2010NOI导刊_04】跑步(Running.pas/c/cpp

<div style="text-indent: 21.1pt"><b>【题目描述】</b></div> <div style="text-indent: 10.5pt">  新牛到部队,CG要求它们每天早上搞晨跑,从A农场跑到B农场。从A农场到B农场中有n-2个路口,分别标上号,A农场为1号,B农场为n号,路口分别为2...n-1号,从A 农场到B农场有很多条路径可以到达,而CG发现有的路口是必须经过的,即每条路径都经过的路口,CG要把它们记录下来,这样CG就可以先到那个路口,观察新牛们有没有偷懒,而你的任务就是找出所有必经路口。</div>

<div style="text-indent: 21.1pt"><b>【输入数据】</b></div> <div style="text-indent: 21pt">第一行两个用空格隔开的整数n3≤n≤<span>2000)和e1≤e≤8000)。</span></div> <div style="text-indent: 21pt">接下来从第<span>2到第e+1行,每行两个用空格隔开的整数pq,表示路口pq之间有路径直达。</span></div> <div style="text-indent: 21pt">输入数据保证必经路口一定存在,并且每个路口都和<span>A农场、B农场相连通。</span></div>

<div style="text-indent: 21.1pt"><b>【输出数据】</b></div> <div style="text-indent: 21pt">第一行一个整数<span>m,表示必经路口的数目。</span></div> <div style="text-indent: 21pt">第二行按从小到大的顺序依次输出每个必经路口的编号,每两个数之间用一个空格隔开。</div> <div style="text-indent: 21pt">注意:不包括起点和终点。</div>

【样例输入】 6 6 1 2 2 4 2 3 3 5 4 5 5 6

【样例输出】 2 2 5

0

 

 

2017-04-16 09:21:56

1

128

N

0

2

0

1681

2010NOI导刊_04】装备运输(Transport.pas/c/cpp

<div style="text-indent: 21.1pt"><b>【题目描述】</b></div> <div style="text-indent: 21pt">德国放松对英国的进攻后,把矛头指向了东边――苏联。</div> <div style="text-indent: 21pt">1943年初,东线的战斗进行到白热化阶段。据可靠情报,90余万德国军队在库尔斯克准备发动浩大攻势。因此,朱可夫元帅要求你立即从远东的军工厂运输大量装备支援库尔斯克前线。</div> <div style="text-indent: 21pt">列车司机告诉你,一趟列车最多可以容纳V体积的武器装备,但是你可能不能装满,因为列车承受不了那么大的重量,一趟列车最多可以承载G单位的重量。同时,军工厂仓库提供给你一份装备清单,详细记录了每件装备的体积、重量和火力。为了有效支援朱可夫元帅,你要找到一种方案,使得总火力值最大。</div>

<div style="text-indent: 21.1pt"><b>【输入数据】</b></div> <div style="text-indent: 21pt">第一行:VG表示最大重量和体积。</div> <div style="text-indent: 21pt">第二行:N表示仓库有N件装备。</div> <div style="text-indent: 21pt">第三行到N+2行:每行3个数Ti Vi Gi表示各装备的火力值、体积和重量。</div>

<div style="text-indent: 21.1pt"><b>【输出数据】</b></div> <div style="text-indent: 21pt">输出一个数,表示可能获得的最大火力值。</div>

【样例输入】 6 5 4 10 2 2 20 3 2 40 4 3 30 3 3

【样例输出】 50 【数据范围】 对于50%的数据,V,G,N≤100; 对于100%的数据,V,G,N≤400

0

 

 

2017-04-16 09:30:22

1

128

N

0

2

0

1682

2010NOI导刊_04】方程的解(equation.pas/c/cpp

<div style="text-indent: 21.1pt"><b>【题目描述】</b></div> <div style="text-indent: 21pt">对于不定方程<span style="font-size: 12pt">a<sub>1</sub>+a<sub>2</sub>+…+a<sub>k-1</sub>+a<sub>k</sub>=g</span>(<span style="font-size: 12pt">x</span>),其中<span>k≥2k∈N﹡,x是正整数,</span><span style="font-size: 12pt">g(x)=x<sup>x</sup> </span>mod 1000<span>xk是给定的数。我们要求的是这个不定方程的正整数解组数。</span></div> <div style="text-indent: 21pt">举例来说,当<span>k=3x=2时,gx=4,原方程即</span><span style="font-size: 12pt">a<sub>1</sub>+a<sub>2</sub>+a<sub>3</sub>=4</span><span style="font-size: 12pt"></span></div> <div style="text-indent: 21pt">这个方程的正整数解有<span>3组,分别为(</span><span style="font-size: 12pt">a<sub>1</sub></span><span style="font-size: 12pt">a<sub>2</sub>a<sub>3</sub></span>)<span style="font-size: 12pt">a=</span><span>211),(121),(112)。</span></div>

<div style="text-indent: 21.1pt"><b>【输入文件】</b></div> <div style="text-indent: 21pt">输入文件<span>equation.in有且只有一行,为用空格隔开的两个正整数,依次为kx</span></div>

<div style="text-indent: 21.1pt"><b>【输出文件】</b></div> <div style="text-indent: 21pt">输出文件<span>equation.out有且只有一行,为方程的正整数解组数。</span></div>

【样例输入】 2

【样例输出】 3 【数据范围】 对于40%的数据,ans≤1016; 对于100%的数据,k≤100x≤231-1k≤gx)。

0

 

 

2017-04-16 09:30:22

1

128

N

0

0

0

1683

2010NOI导刊_05】无穷的序列

<div style="text-indent: 10.5pt">【问题描述】</div> <div style="text-indent: 10.5pt">有一个无穷序列如下:</div> <div style="text-indent: 10.5pt">110100100010000100000…</div> <div style="text-indent: 10.5pt">请你找出这个无穷序列中指定位置上的数字</div>

<div style="text-indent: 10.5pt">【输入】</div> <div style="text-indent: 10.5pt">第一行一个正整数N,表示询问次数;</div> <div style="text-indent: 10.5pt">接下来的N行每行一个正整数AiAi表示在序列中的位置。</div> <p></p>

<div style="text-indent: 10.5pt">【输出】</div> <div style="text-indent: 10.5pt">N行,每行为01,表示序列第Ai位上的数字。</div>

【输入样例】 4 3 14 7 6

【输出样例】 0 0 1 0 【数据范围】 对于100%的数据有N≤1500000Ai≤10^9

0

 

 

2017-04-16 09:30:22

1

128

N

0

6

0

1684

2010NOI导刊_05】汤姆斯的天堂梦(par

<div style="text-indent: 10.5pt">【问题描述】</div> <div style="text-indent: 21pt">汤姆斯生活在一个等级为0的星球上。那里的环境极其恶劣,每天12小时的工作和成堆的垃圾让人忍无可忍。他向往着等级为N的星球上天堂般的生活。</div> <div style="text-indent: 21pt">有一些航班将人从低等级的星球送上高一级的星球,有时需要向驾驶员支付一定金额的费用,有时却又可以得到一定的金钱。</div> <div style="text-indent: 21pt">汤姆斯预先知道了从0等级星球去N等级星球所有的航线和需要支付(或者可以得到)的金钱,他想寻找一条价格最低(甚至获得金钱最多)的航线。</div>

<div style="text-indent: 10.5pt">【输入】</div> <div style="text-indent: 21pt">第一行一个正整数NN≤100,接下来的数据可分为N个段落</div> <div style="text-indent: 21pt">每段的第一行一个整数Ki(Ki≤100),表示等级为i的星球有Ki个。</div> <div style="text-indent: 21pt">接下来的Ki中第Tij行依次表示与等级为i,编号为j的星球相连的等级为i-1的星球的编号和此航线需要的费用(正数表示支出,负数表示收益,费用的绝对值不超过1000)。每行以0结束,每行的航线数≤100</div>

<div style="text-indent: 10.5pt">【输出】</div> <div style="text-indent: 21pt">输出所需(或所得)费用。正数表示支出,负数表示收益。</div>

【输入样例】 3 2 1150 150 3 1-52100 130 2400 2 11253-50 2-193-200

【输出样例】 -1 【数据范围】 对于100%的数据 N≤100 Ki≤100

0

<p>【样例解释】<br /> 如图<br /> <img height="355" width="407" alt="" src="http://10.208.83.181:80/upload/201307/p1684.jpg" /></p>

 

2017-04-16 09:30:22

1

128

N

0

4

0

1685

生化危机

X博士想造福人类, 研发一种可以再生肢体的药物, 可是很不幸......研究失败了, 他在蜥蜴身上实验的时候, 蜥蜴发生了变异, 更糟糕的是, 蜥蜴逃出了生化实验室.<br /> <br /> 恐怖的事情发生了, 疫情以X博士所在的城市为中心向四周扩散开, 最终, 整个地球上的城市都被感染了.假设整个地球一共有N个城市, N个城市是连通的, N-1条通道把他们连接起来.病毒会以一座城市为中心,在一天的时间内, 会把和他相连的周围的所有城市感染. 那么, 多少天的时间, 整个地球的城市都感染呢?<br />

第一行输入一个T(T <= 50), 表示一共有T组测试数据.<br /> 每组数据第一行两个数n, k. n表示有n(2 <= n <= 10000)个城市, 代表城市1-n, kX博士所在的城市.<br /> 接下来n-1, 每行有两个数u, v, 表示城市uv之间有一条通道.<br />

<span style="color:#333333;font-family:source_code_pro, PingFangSC-Regular, "font-size:15px;background-color:#FFFFFF;">每组数据第一行输出第一个数 x , 表示整个地球感染需要x.<br /> 接下来 x 个数, i个数表示第i天感染了城市的数量.<br /> (注意, 每组数据第二行每个数据后边都有一个空格)<br /> </span><span style="color:#333333;font-family:source_code_pro, PingFangSC-Regular, "font-size:15px;background-color:#FFFFFF;"></span>

2 3 1 1 2 2 3 3 2 1 2 2 3

3 1 1 1 2 1 2

0

 

QDU创新实验室第二次月赛

2017-04-16 09:33:15

1

128

N

1

2

0

1687

2010NOI导刊_07】数列(sequence.pas/c/cpp

<div style="margin: 0cm 0cm 0pt 18pt; line-height: 150%" align="left"><b><span style="font-size: 12pt; line-height: 150%">问题描述</span></b></div> <div style="text-indent: 24pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">一个数列定义如下:f(1)=1, f(2)=1, f(n)=(A*f(n-1)+B*f(n-2))mod 7。给定ABn的值,要求技术f(n)的值。</span></div>

<div style="margin: 0cm 0cm 0pt 18pt; line-height: 150%" align="left"><b><span style="font-size: 12pt; line-height: 150%">输入格式</span></b></div> <div style="text-indent: 24pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">输入文件(sequence.in)仅一行,包含3个整数ABn,其中(1</span><span style="font-size: 12pt; line-height: 150%">≤</span><span style="font-size: 12pt; line-height: 150%">A, B</span><span style="font-size: 12pt; line-height: 150%">≤</span><span style="font-size: 12pt; line-height: 150%">1000, 1</span><span style="font-size: 12pt; line-height: 150%">≤</span><span style="font-size: 12pt; line-height: 150%">n</span><span style="font-size: 12pt; line-height: 150%">≤</span><span style="font-size: 12pt; line-height: 150%">100,000,000</span><span style="font-size: 12pt; line-height: 150%">)。</span></div>

<div style="text-indent: 24.1pt; line-height: 150%" align="left"><b><span style="font-size: 12pt; line-height: 150%">输出格式</span></b></div> <div style="text-indent: 24pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">输出文件(sequence.out)仅一行,一个整数,即f(n)的值。</span></div>

输入样例 1 1 3

输出样例 2 说明:若出入样例为1 2 10,则输出为5。 数据规模 20%的数据,n≤1,000 40%的数据,n≤100,000 100%的数据,n≤100,000,000

0

 

 

2017-04-16 09:35:46

1

128

N

0

4

0

1688

2010NOI导刊_07】最长路(path.pas/c/cpp

<div style="margin: 0cm 0cm 0pt 18pt; line-height: 150%" align="left"><b><span style="font-size: 12pt; line-height: 150%">问题描述</span></b></div> <div style="text-indent: 24pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">G为有n个顶点的有向无环图,G中各项点的编号为1n,且当<i,j>G中的一条边时有i<j。设w(i,j)为边<i,j>的长度,请设计算法,计算图G<1,n>间的最长路径。</span></div>

<div style="text-indent: 24.1pt; line-height: 150%" align="left"><b><span style="font-size: 12pt; line-height: 150%">输入格式</span></b></div> <p><span style="font-size: 12pt">输入文件path. in的第一行有两个整数nm,表示有n个顶点和m条边,其中(2≤n≤1500, m≤50000;接下来m行中每行输入3个整数abv表示从a点到b点有条边,边的长度为v</span></p>

<div style="text-indent: 24.1pt; line-height: 150%" align="left"><b><span style="font-size: 12pt; line-height: 150%">输出格式</span></b></div> <div style="text-indent: 24pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">输出文件path.out,一个整数,即1n之间的最长路径。如果1n之间设连通,输出-1</span></div>

输入样例 2 1 1 2 1

输出样例 1 说明:瑞出入样例为2 0,则输出为-1。 数据规模 20%的数据,n≤100, m≤1000 40%的数据,n≤1,000 m≤10000 100%的数据,n≤1,500, m≤50000

0

 

 

2017-04-16 09:35:46

1

128

N

0

4

0

1689

2010NOI导刊_07】木棍(wooden.cpp/pas/c

<div style="margin: 0cm 0cm 0pt 18pt; line-height: 150%" align="left"><b><span style="font-size: 12pt; line-height: 150%">问题描述</span></b></div> <div style="text-indent: 24pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">n根木棍,每根的长度1和重量w已知。这些木棍将被一台机器一根一根地加工。机器需要一些启动时间来做准备工作,启动时间与木棍被加工的具体情况有关。启动时间遵循以下规则:</span></div> <div style="margin: 0cm 0cm 0pt 18pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">1.</span><span style="font-size: 12pt; line-height: 150%">加工第一根木棍的启动时间为1分钟。</span></div> <div style="text-indent: 18pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">2.</span><span style="font-size: 12pt; line-height: 150%">加工完长度为l<sub>i</sub>,重量问w<sub>i</sub>的木棍后,紧跟着加工长度为l<sub>i+1</sub>,重量为w<sub>i+1</sub>的木棍时,若l<sub>i</sub>≤l<sub>i+1</sub>,w<sub>i</sub>≤w<sub>i+</sub>1,则加工木棍i+1时,不需要启动时间。例如:有5根木棍,它们的长度和重量为(9,4),(2,5),(1,2),(5,3),(4,1),则最小总启动时间为2分钟(加工序列为(4,1),(5,3),(9,4),(1,2),(2,5))。</span></div>

<div style="margin: 0cm 0cm 0pt 17.95pt; text-indent: 5.9pt; line-height: 150%" align="left"><b><span style="font-size: 12pt; line-height: 150%">输入格式</span></b></div> <div style="text-indent: 24pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">输入文件wooden.in第一行一个整数n1≤n≤5000,表示木棍的数量。第二行2*n个整数,l<sub>1</sub>,w<sub>1</sub>,l<sub>2</sub>,w<sub>2</sub>,……l<sub>n</sub>, w<sub>n</sub>(1≤l<sub>i</sub>,w<sub>i</sub>≤10000),为各根木棍的长度和重量,这2*n个整数以若干个空格分隔。</span></div>

<div style="text-indent: 24.1pt; line-height: 150%" align="left"><b><span style="font-size: 12pt; line-height: 150%">输出格式</span></b></div> <div style="text-indent: 24pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">输出文件wooden.out仅一行,一个整数,即最小总启动时间。</span></div>

样例输入1 5 4 9 5 2 2 1 3 5 1 4 样例输入2 3 2 2 1 1 2 2

样例输出1 2 样例输出2 1

0

 

 

2017-04-16 09:35:46

1

128

N

0

4

0

1690

2010NOI导刊_07】翻转游戏(flip.cpp/pas/c

<div style="margin: 0cm 0cm 0pt 18pt; line-height: 150%" align="left"><b><span style="font-size: 12pt; line-height: 150%">问题描述</span></b></div> <div style="text-indent: 24pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">翻转游戏是在一个4*4格的长方形上进行的,在长方形的16个格上每个格子都放着一个双面的物件。每个物件的两个面,一面是白色的,另一面是黑色,每个物件要么白色朝上,要么黑色朝上,每一轮你只能翻35个物件,从而由黑到白地改变这些物件上面的颜色,反之亦然。每一轮被选择翻转的物件遵循以下规则:</span></div> <div style="margin: 0cm 0cm 0pt 39pt; text-indent: -18pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">1.<span style="font: 7pt 'Times New Roman'">    </span></span><span style="font-size: 12pt; line-height: 150%">16个物件中任选一个。</span></div> <div style="margin: 0cm 0cm 0pt 39pt; text-indent: -18pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">2.<span style="font: 7pt 'Times New Roman'">    </span></span><span style="font-size: 12pt; line-height: 150%">翻转所选择的物件的同时,所有与它相邻的左方物件、右方物件、上方物件和下方物件(如果有的话),都要跟着翻转。</span></div> <div style="margin: 0cm 0cm 0pt 39pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">以下为例:</span></div> <div style="margin: 0cm 0cm 0pt 39pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">bwbw</span></div> <div style="margin: 0cm 0cm 0pt 39pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">wwww</span></div> <div style="margin: 0cm 0cm 0pt 39pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">bbwb</span></div> <div style="margin: 0cm 0cm 0pt 39pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">bwwb</span></div> <div style="margin: 0cm 0cm 0pt 39pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">这里”b”表示该格子放的物件黑色面朝上,”w”表示该格子放的物件白色朝上。如果我们选择翻转第三行的第一个物件(如下图所示),那么格子状态将变为:</span></div> <div style="margin: 0cm 0cm 0pt 39pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">bwbw</span></div> <div style="margin: 0cm 0cm 0pt 39pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">bwww</span></div> <div style="margin: 0cm 0cm 0pt 39pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">wwwb</span></div> <div style="margin: 0cm 0cm 0pt 39pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">wwwb</span></div> <div style="margin: 0cm 0cm 0pt 39pt; line-height: 150%" align="left"></div> <div style="text-indent: 24pt; line-height: 150%" align="left"> <img height="181" width="240" alt="" src="http://10.208.83.181:80/upload/201307/p1690.jpg" /></div> <p><span style="font-size: 12pt">游戏的目标是翻转到所有的物件白色朝上或黑色朝上。你的任务就是写一个程序求最少的翻转次数来实现这一目标。</span></p>

<div style="text-indent: 24.1pt; line-height: 150%" align="left"><b><span style="font-size: 12pt; line-height: 150%">输入格式</span></b></div> <div style="text-indent: 24pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">输入文件flip.in包含4行,每行4个字符,每个字符”w”“b”表示游戏开始时格子上物件的状态。</span></div>

<div style="text-indent: 24.1pt; line-height: 150%" align="left"><b><span style="font-size: 12pt; line-height: 150%">输出格式</span></b></div> <div style="text-indent: 24pt; line-height: 150%" align="left"><span style="font-size: 12pt; line-height: 150%">输出文件flip.out仅一个整数,即从给定状态到实现这一任务的最少翻转次数。如果给定的状态已经实现了目标就输出0,如果不可能实现目标就输出“Impossible”</span></div>

输入样例 bwwb bbwb bwwb bwww

输出样例 4

0

 

 

2017-04-16 09:35:46

1

128

N

0

3

0

1691

2010NOI导刊_12】圆圈舞蹈(circle.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">熊大妈的奶牛在时针的带领下,围成了一个圆圈跳舞。由于没有严格的教育,奶牛们之间的间隔不一致。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">奶牛想知道两只最远的奶牛到底隔了多远。奶牛A B 的距离为A 顺时针走和逆时针走,到达B的较短路程。告诉你相邻两个奶牛间的距离,请你告诉奶牛两只最远的奶牛到底隔了多远。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行一个整数 N,表示有N 只奶牛。(2≤N≤100000)</span></p> <p><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">接下来2N+1 行,第I 行有一个数,表示第I-1 头奶牛顺时针到第I 头奶牛的距离。(1≤距离≤maxlongint,距离和≤maxlongint)</span></p> <p><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">N+l 行的数表示第N 头奶牛顺时针到第1 头奶牛的距离。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一行,表示最大距离。</span></p> <p></p>

【输入样例】 5 1 2 3 4 5

【输出样例】 7 Hint】 所有奶牛 I J 之间的距离和到达方式(顺为顺时针,逆为逆时针)如下: I\J 1 2 3 4 5 1 O 1 () 3() 6(顺) 5(逆) 2 1(逆) O 2(顺) 5(顺) 6(逆) 3 3(逆) 2(逆) 0 3(顺) 7(顺) 4 6(逆) 5(逆) 3(逆) 0 4() 5 5(顺) 6(顺) 7(逆) 4(逆) 0 所以,最远的两头奶牛为3 5,距离是7

0

<p></p>

 

2017-04-16 09:36:08

1

128

N

0

3

0

1692

2010NOI导刊_12】竞赛排名(compe.cpp/pas/c

<p style="margin: 0px 0px 1em; padding: 0px; line-height: 27px; color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px;">【问题描述】<br /> 某市组织了一次中学生科技全能竞赛,每个选手要参加数学、物理、化学、天文、地理、生物、计算机和英语共八项竞赛,最后综合八项竞赛的成绩排出总名次。选手编号依次为:1,2…NN为参赛总人数)。</p> <p style="margin: 0px 0px 1em; padding: 0px; line-height: 27px; color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px;"><a href="http://www.ssxdzx.net/images/1388.gif" rel="lightbox[671]" style="outline: none; color: rgb(110, 161, 219);"><img src="http://www.ssxdzx.net/images/1388.gif" style="border: none; height: auto; max-width: 100%; width: auto;" alt="" /></a><br /> 排名规则如下:<br /> 1.总位置分高的选手名次在前:<br /> 2.若两个或两个以上的选手总位置分相同,则总分高的选手名次在前:<br /> 3.若两个或两个以上的选手总位置分和总分均相同,则编号在前的选手名次在前。<br /> 请你为竞赛组委会编一程序,计算本次全能竞赛的总排名情况。</p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">文件的第一行为参赛总人数 N(1≤N≤1000)</span></p> <p></p> <p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">从第二行到第N 行依次为编号1 到编号为N 的选手的成绩,</span></p> <p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">每行有8 0100 之间的整数,代表该选手的8 项竞赛成绩Xi1,Xi2Xi8</span></p> <p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">同一行相邻两个数之间用一个空格符隔开。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">文件有 N 行,从第一行到第N 行依次为排名第1 的选手的编号,排名第2 的选手的编号,,排名第N 的选手的编号。</span></p> <p></p>

【输入样例】 3 72 82 73 68 95 86 82 90 72 90 50 60 80 70 65 80 72 82 73 68 95 86 82 90

【输出样例】 1 3 2

0

 

 

2017-04-16 09:36:08

1

128

N

0

3

0

1693

2010NOI导刊_12】奶牛晒衣服(dry.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">在熊大妈英明的带领下,时针和它的同伴生下了许多牛宝宝。熊大妈决定给每个宝宝都穿上可爱的婴儿装。于是,为牛宝宝洗晒衣服就成了很不爽的事情。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">圣人王担负起了这个重任。洗完衣服后,你就要弄干衣服。衣服在自然条件下用 1 的时间可以晒干A 点湿度。抠门的熊大妈买了1 台烘衣机。使用烘衣机可以让你用1 的时间使1 件衣服除开自然晒干的A 点湿度外,还可烘干B 点湿度,但在1 的时间内只能对1 件衣服使用。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">N 件的衣服因为种种原因而不一样湿,现在告诉你每件衣服的湿度,要你求出弄干所有衣服的最少时间(湿度为0 为干)。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行 NAB;接下来N 行,每行一个数,表示衣服的湿度(1≤湿度,AB≤5000001≤N≤500000)</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一行,最少时间。</span></p> <p></p>

【输入样例】 3 2 1 1 2 3

【输出样例】 1 Hint】 第 1 个时间内,用机器处理第3 件衣服,此外,所有衣服自然晒干2。花费1 时间全部弄干。

0

 

 

2017-04-16 09:36:08

1

128

N

0

3

0

1694

2010NOI导刊_12】奶牛排队(tahort.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">奶牛在熊大妈的带领下排成了一条直队。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">显然,不同的奶牛身高不一定相同……</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">现在,奶牛们想知道,如果找出一些连续的奶牛,要求最左边的奶牛 A 是最矮的,最右边的B 是最高的,且B 高于A 奶牛,中间如果存在奶牛,则身高不能和AB 奶牛相同。问这样的奶牛最多会有多少头?</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">从左到右给出奶牛的身高,请告诉它们符合条件的最多的奶牛数(答案可能是02,但不会是1)。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行一个数 N (2≤N≤l00000),表示奶牛的头数。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">接下来N 个数,每行一个数,从上到下表示从左到右奶牛的身高(1≤身高≤maxlongint)</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行,表示最多奶牛数。</span></p> <p></p>

【输入样例】 5 1 2 3 4 1

【输出样例】 4 Hint】 取第 1 头到第4 头奶牛,满足条件且为最多。

0

 

 

2017-04-16 09:36:08

1

128

N

0

3

0

1695

2010NOI导刊_16】方程(euqation.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">给出非负整数 N,统计不定方程x+y^2+z^3=n的非负整数解(x, y, z)的组数。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">仅含一个非负整数 N</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">仅含一个非负整数表示解的组数。</span></p> <p></p>

【输入样例】 5

【输出样例】 6 Hint】 六组解分别是(x,y,z)=(0,2,1),(1,2,0),(3,1,1),(4,0,1),(4,1,0),(5,0,0)。 【数据规模】 40%的数据中N≤10^4 60%的数据中N≤10^8 100%的数据中N≤10^16

0

 

 

2017-04-16 09:36:08

1

128

N

0

2

0

1696

2010NOI导刊_16】也是个方程(muti.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">已知 c a1,…,an全都是正整数,求满足a1*b1+a2*b2+…+an*bn=c的非负整数解{b1,b2,…,bn}的组数。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行是 n c</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第二行是 n 个数,分别表示1,…, n a a</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输出解的组数(结果对 999983 取模)。</span></p> <p></p>

【输入样例】 2 4 1 2

【输出样例】 3 【数据规模】 30%的数据中n≤10c≤100 100%的数据中n≤100c≤10^5

0

 

 

2017-04-16 09:36:08

1

128

N

0

1

0

1697

2010NOI导刊_16】交错匹配(cross.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">有两排非负整数 A[1..N]B[1..M],如果A[i]=B[j]=k,那么可以在A[i]B[j]之间连一条线,称为一条k 匹配,每个数至多连一条线。另外,每个k 匹配都必须跟一个r 匹配相交,且k</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">≠r。现在要求一个最大的匹配数。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入文件第一行包含两个正整数 n m</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第二行 n 个自然数,表示a[i]</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第三行 m 个自然数,表示b[i]</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输出文件只有一个数字,即最大匹配数。</span></p> <p></p> <p></p>

【输入样例 1 12 11 1 2 3 3 2 4 1 5 1 3 5 10 3 1 2 3 2 4 12 1 5 5 3

【输出样例1 8

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">30%的数据满足n,m≤30</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">60%的数据满足n,m≤200</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">100%的数据满足n,m≤10000<所有数≤32767</span></p> <p></p> <p></p>

 

2017-04-16 09:36:08

1

128

N

0

0

0

1698

2010NOI导刊_15】中位数(median.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">给出 1~n 的一个排列,统计该排列有多少个长度为奇数的连续子序列的中位数是b。中位数是指把所有元素从小到大排列后,位于中间的数。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行为两个正整数 n b,第二行为1~n 的排列。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输出一个整数,即中位数为 b 的连续子序列个数。</span></p> <p></p> <p></p>

【输入样例】 median1.in 5 4 1 2 3 4 5 median2.in 6 3 1 2 4 5 6 3 median3.in 7 4 5 7 2 4 3 1 6

【输出样例】 median1.out 2 median2.out 1 median3.out 4

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Hint</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第三个样例解释:{4}{724}{57243}{5724,316}</span></p> <p></p> <p><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于100%nn<=100000</span></p> <p></p>

 

2017-04-16 09:36:08

1

128

N

0

0

0

1699

2010NOI导刊_15】打砖块(brike.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">在一个凹槽中放置了 n 层砖块、最上面的一层有n 块砖,从上到下每层依次减少一块砖。每块砖都有一个分值,敲掉这块砖就能得到相应的分值。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">如果你想敲掉第 i 层的第j 块砖的话,若i=1,你可以直接敲掉它;若i>1,则你必须先敲掉第i-1 层的第j 和第j+1 块砖。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">你现在可以敲掉最多 m 块砖,求得分最多能有多少。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入文件的第一行为两个正整数 n m;接下来n 行,描述这n 层砖块上的分值a[i][j],满足0≤a[i][j]≤100</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输出文件仅一行为一个正整数,表示被敲掉砖块的最大价值总和。</span></p> <p></p> <p></p>

【输入样例】 4 5 2 2 3 4 8 2 7 2 3 49

【输出样例】 19

0

 

 

2017-04-16 09:36:08

1

128

N

0

2

0

1700

2010NOI导刊_15】最小密度路径(paht.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">给出了一张有 N 个点M 条边的加权有向无环图,接下来有Q 个询问,每个询问包括2 个节点X Y,要求算出从X Y 的一条路径,使得密度最小(密度的定义为,路径上边的权值和除以边的数量)。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行包括两个整数 N M</span></p> <p><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"> 2 到第M+1 行,每行三个数字ABW,表示从A B 有一条权值为W 的有向边。</span></p> <p><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"> M+2 行只有一个整数Q</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">接下来 Q 行,每行有两个整数X Y,表示一个询问。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于每个询问输出一行,表示该询问的最小密度路径的密度(保留3 位小数),如果不存在从X </span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Y 的一条路径,则输出“OMG!”</span></p> <p></p> <p></p>

【输入样例 】 3 3 1 3 5 2 1 6 2 3 6 2 1 3 2 3

【输出样例】 5.000 5.500

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 60%的数据,有1≤N≤101≤M≤1001≤W≤10001≤Q≤1000</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 100%的数据,有1≤N≤501≤M≤10001≤W≤1000001≤Q≤100000</span></p> <p></p> <p></p>

 

2017-04-16 09:36:08

1

128

N

1

2

0

1701

2010NOI导刊_16】又是方程(equation.cpp/pas/c

<p style="margin: 0px 0px 1em; padding: 0px; line-height: 27px; color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px;">【问题描述】</p> <p style="margin: 0px 0px 1em; padding: 0px; line-height: 27px; color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px;">给出一个字符串,表是一个方程。<br /> 保证里面系数不会超过 1,000,000,000 <br /> 保证方程有且只有一解,而且方程只会有一个未知数 X,且X 的最高指数也只会有1<br /> 方程中所有的系数都是整数,且系数是 1 就会被省略。<br /> 只会出现+-符号,不会出现乘、除。</p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入一个字符串,表示方程。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输出 x 的解。保留三位小数。</span></p> <p></p>

【输入样例】 6x+7x+8x+1=6x+7x+9x

【输出样例】 1.000

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">100%方程长度不会超过255</span></p> <p></p> <p></p>

 

2017-04-16 09:36:29

1

128

N

1

2

0

1702

2010NOI导刊_03】最接近神的人(sophist.cpp/pas/c

<p style="margin: 0px 0px 1em; padding: 0px; line-height: 27px; color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px;">【问题描述】</p> <p style="margin: 0px 0px 1em; padding: 0px; line-height: 27px; color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px;">传说中珠穆朗玛峰下有座古代人修建的神庙,神庙的地下室里有古代王室的遗产,但数千年来从未有人到达过……探险者小FF 一直梦想成为世界上最富有的人和最杰出的探险家并被永载史册。在证明了这个洞确实存在后,小FF 做好了充足准备,来到了神庙。<br /> 当他走到神庙地下最底层时,发现正前方有一扇巨石门,门上雕刻着一幅古代人进行某种活动的图案。而石门上方用古代文写着神的殿堂。小FF 猜想里面应该就有王室的遗产了。但现在的问题是如何打开这扇门……<br /> 仔细研究后,他发现门上的图案大概是说:古代人认为只有智者才是最容易接近神明的。而最聪明的人往往通过一种仪式选拔出来。仪式大概是指,即将隐退的智者为他的候选人写下一串无序的数字,并让他们进行一种操作,即交换序列中相邻的两个元素。而用最少的交换次数使原序列变成不下降序列的人即是下一任智者。<br />  FF 发现门上同样有着n 个数字。于是他认为打开这扇门的秘诀就是找到让这个序列变成不下降序列所需要的最小次数。但小FF 不会……只好又找到了你,并答应事成之后与你三七分……</p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行为一个整数 n,表示序列长度</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第二行为 n 个整数,表示序列中每个元素。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一个整数 ans,即最少操作次数。</span></p> <p></p>

【输入样例】 4 2 8 0 3

【输出样例】 3

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Hint</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">开始序列为 2 8 0 3,目标序列为0 2 3 8,可进行三次操作的目标序列:</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">1swap (8,0):2 0 8 3</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">2swap (2,0):0 2 8 3</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">3swap (8,3):0 2 3 8</span></p> <p></p> <p><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 30%的数据1≤n≤10^4</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 100%的数据1≤n≤5*10^5</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">-maxlongint≤A[i]≤maxlongint</span></p> <p></p>

 

2017-04-16 09:36:29

1

128

N

1

2

0

1703

2011NOI导刊_05Rabbit Numberrabbit.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"> S(N)表示N 的各位数字之和,如S(484)=4+8+4=16S(22)=2+2=4。如果一个正整数x满足S(x*x)=S(x)*S(x),我们称x Rabbit Number。比方说,22 就是一个Rabbit Number,因S(484)=S(22)*S(22)</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">现在,给出一个区间[L,R],求在该区间内的Rabbit Number 的个数。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入仅一行,为空格隔开的两个数 L R</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输出仅一行一个整数,表示所求 Rabbit Number 的个数。</span></p> <p></p>

【输入样例1 22 22 【输入样例2 484 484 【输入样例3 1 58 【输入样例4 58 484 【输入样例5 1000000000 1000000000

【输出样例1 1 【输出样例2 0 【输出样例3 12 【输出样例4 24 【输出样例5 1

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">1≤L≤R≤10^9</span></p> <p></p> <p></p>

 

2017-04-16 09:36:29

1

128

N

1

1

0

1704

2011NOI导刊_05Play with Powerplay.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Masha Stas 正在玩一个游戏。在游戏的开始,给出一个定值N,同时有两个正整数A B,初始时满足AB≤NMasha 先手。每一回合,玩家要将A B 的其中一个数加上1,但不能令到AB>N,否则该玩家输。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">现在,Masha 想知道假如两人都使用最优策略,对于一个特定的N,不同的AB 的初始值谁将获胜呢?</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入第一行为一个正整数 N</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入第二行为一个正整数 T,表示测试数据个数。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">下面 T 行,每行有两个正整数AiBi,描述了一组测试数据<Ai,Bi,N>,含义如题目描述。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对每组数据输出一行。如果先手Masha 获胜,输出“Masha”;如果后手Stas 获胜,输出Stas;如果平手则输出“Missing”(不用输出引号)。</span></p> <p></p> <p></p>

【输入样例1 9 2 2 2 1 4 【输入样例2 16807 3 5 5 1 100 100 1 【输入样例3 3 1 3 1

【输出样例1 Masha Missing 【输出样例2 Masha Missing Stas 【输出样例3 Stas

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"> 30%的数据,1≤N≤2000</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"> 100%的数据有:1≤N≤10^8</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">1≤T≤100</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">1≤Ai1≤BiAiBi≤N</span></p> <p></p> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

1

0

1705

2011NOI导刊_05Color the Axisaxis.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">在一条数轴上有 N 个点,分别是1N。一开始所有的点都被染成黑色。接着我们进行M 次操作,第i 次操作将[Li,Ri]这些点染成白色。请输出每个操作执行后剩余黑色点的个数。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入一行为 N M。下面M 行每行两个数LiRi</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输出 M 行,为每次操作后剩余黑色点的个数。</span></p> <p></p> <p></p>

【输入样例】 10 3 3 3 5 7 2 8

【输出样例】 9 6 3

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 30%的数据,有1≤N≤20001≤M≤2000</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 100%的数据,有1≤Li≤Ri≤N≤2000001≤M≤200000</span></p> <p></p> <p></p>

 

2017-04-16 09:36:29

1

128

N

1

2

0

1706

2011NOI导刊_02】蠕虫游戏(worm.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">蠕虫是一个古老的电脑游戏,它有许多版本。但所有版本都有一个共同规则:操纵一条蠕虫在屏幕上转圈,并试着去避免撞到自己或障碍物。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">这里我们将模拟一个简单的版本。游戏将在 50×50 的棋盘上进行,棋盘的左上角为(1,1),蠕虫在初始时是一串20 个相连的方格。所谓连接是指方格在水平或垂直方向上相接。蠕虫开始时是水平地伸展开的,从(2511)到(2530)。其中(2530)是它的头。蠕虫只能向东(E),西(W),南(S),北(N)四个方向移动,但不能向自己移动,因此在开始时向西(W)是不允许的。每次移动时,蠕虫向给定的方向移动,一次只移动一格,并且保证它的长度不变。因此只有蠕虫的头和尾所占据的方格在移动一步后被改变。注意:蠕虫的头能移动到虫尾刚刚让出的空格。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">你将被给定一系列移动指令并模拟虫的移动,直到:蠕虫撞上了自己;蠕虫越出了棋盘;蠕虫成功地完成了这些指令。在前两种情况下你应当忽略剩下的指令。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">每个输入文件包含了很多组数据。每个数据占2 行,第一行是一个整数(n<100),表示移动指令的指令数(以n=0 表示输入结束);第2 行包括了n 个字符(EWSN),字符之间没有空格,表示移动的指令。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">每个数据输出一行,格式为以下 3 种中的一种(m 是你要决定输出的步数):</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">The worm ran into itself on move m.</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">The worm ran off the board on move m.</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">The worm successfully made all m moves.</span></p> <p></p> <p></p>

【输入样例】 18 NWWWWWWWWWWSESSSWS 20 SSSWWNENNNNNWWWWSSSS 30 EEEEEEEEEEEEEEEEEEEEEEEEEEEEEE 13 SWWWWWWWWWNEE 0

【输出样例】 The worm successfully made all 18 moves. The worm ran into itself on move 9. The worm ran off the board on move 21. The worm successfully made all 13 moves.

0

 

 

2017-04-16 09:36:29

1

128

N

2

2

0

1707

2011NOI导刊_09】直角三角形(right.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">平面上给定 n 个两两不同的整数点,统计以给定的点为顶点,其直角边平行于坐标轴的直角三角形的个数。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入文件第一行是一个整数 n</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">以下 n 行,每行是一个点的坐标。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输出一个整数,表示统计结果。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例】 4 0 0 0 1 1 0 1 1

【输出样例】 4

0

<div>【数据规模】</div> <div></div> <div>30%的数据满足n≤100</div> <div>50%的数据满足n≤1000</div> <div>100%的数据满足0<n≤100,000,所有坐标不超过32 位整数范围。</div> <p></p>

 

2017-04-16 09:36:29

1

128

N

1

1

0

1708

2011NOI导刊_10】聪明的打字员(typer.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">阿兰是某机密部门的打字员,出于保密的需要,该部门用于输入密码的键盘是特殊设计的,键盘上没有数字键,而只有以下六个键:Swap0, Swap1, Up, Down, Left, Right。为了说明这六个键的作用,我们先定义录入区的6 个位置的编号,从左至右依次为123456。下面列出每个键的作用:</span></p> <p><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Swap0:按Swap0,光标位置不变,将光标所在位置的数字与录入区的1 号位置的数字(左起第一个数字)交换。如果光标已经处在录入区的1 号位置,则按Swap0 键之后,录入区的数字不变;</span></p> <p><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Swap1:按Swap1,光标位置不变,将光标所在位置的数字与录入区的6 号位置的数字(左起第六个数字)交换。如果光标已经处在录入区的6 号位置,则按Swap1 键之后,录入区的数字不变;</span></p> <p><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Up:按Up,光标位置不变,将光标所在位置的数字加1(除非该数字是9)。例如,如果光标所在位置的数字为2,按Up 之后,该处的数字变为3;如果该处数字为9,则按Up 之后,数字不变,光标位置也不变;</span></p> <p><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Down:按Down,光标位置不变,将光标所在位置的数字减1(除非该数字是0),如果该处数字为0,则按Down 之后,数字不变,光标位置也不变;</span></p> <p><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Left:按Left,光标左移一个位置,如果光标已经在录入区的1 号位置(左起第一个位置)上,则光标不动;</span></p> <p><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Right:按Right,光标右移一个位置,如果光标已经在录入区的6 号位置(左起第六个位置)上,则光标不动。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">当然,为了使这样的键盘发挥作用,每次录入密码之前,录入区总会随机出现一个长度为 6 的初始密码,而且光标固定出现在1 号位置上。当巧妙地使用上述六个特殊键之后,可以得到目标密码,这时光标允许停在任何一个位置。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">现在,阿兰有一个6 位的数字密码,请编写一个程序,求出录入一个密码需要的最少的击键次数。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">仅一行,含有两个长度为 6 的数,前者为初始密码,后者为目标密码,两数间用空格隔开。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">仅一行,含有一个正整数,为最少需要的击键次数。</span></p> <p></p> <p></p>

【输入样例】 123456 654321

【输出样例】 11

0

 

 

2017-04-16 09:36:29

1

128

N

0

0

0

1709

2011NOI导刊_06】砍树(cut.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">A 在一条水平的马路上种了n 棵树,过了几年树都长得很高大了,每棵树都可以看作是一条长度为a[i]的竖线段。由于有的树过于高大,挡住了其他的树,使得另一些树得不到阳光。如果有两棵树i ji 顶端与j 底端连线的倾角大于45 度,我们就定义为i 挡住了j 。现在小A 希望将一些树砍低,使得不存在挡住的情况。他想知道总共最少需要砍掉多少长度,请你来帮他计算一下。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">注意,如果同一位置有两棵树的话,根据题意,我们只能将这两棵树都砍成高度为 0 才能保证它们不相互挡住,但是高度为0 并不代表这棵树不存在。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行一个正整数n ,表示有n 棵树。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">接下来n . 每行两个正整数p[il a[i] ,表示一棵树的位置和高度。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输出一个数,表示最少砍断多少长度。</span></p> <p></p> <p></p>

【输入样例】 3 0 2 1 2 3 3

【输出样例】 3

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 50%的数据,n≤100</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 100%的数据,n≤100,0000<p[i]a[i]≤10,000</span></p> <p></p> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

1

0

1710

2011NOI导刊_06】统计方案(count.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">B 写了一个程序,随机生成了n 个正整数,分别是a[i]..a[n],他取出了其中一些数,并把它们乘起来之后模 p,得到了余数c。但是没过多久,小B 就忘记他逃了哪些数,他想把所有可能的取数方案都找出来。你能帮他计算一下一共有多少种取数方案吗?请把最后的方案数模1000000007 后输出。小 B 记得他至少取了一个数。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行三个正整数 npc,含义如题目所述。接下来一行有n 个正整数,表示生成的n 个随机数。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一个数。方案数模 1000000007</span></p> <p></p> <p></p>

【输入样例】 2 7 2 1 2 4

【输出样例】 2

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"> 30%的数据有:n≤16p≤10000</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"> 100%的数据有:n≤32p≤10^9c≤10^9a[i]<pp 是质数。</span></p> <p></p> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

0

0

1711

2011NOI导刊_06】魔棒(magic.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">有一个英雄,初始生命值是hp(生命值无上限),在接下来的n 秒内,每秒会受到一次伤害,第i 秒受到的伤害值为a[i]。这个英雄4 有一个道具魔杖,魔杖的初始能量为0,每受到一次伤害,积攒1 点能量。在英雄受到伤害后,可以立即释放魔棒中的能量,恢复15×[能量点数]的生命值,且魔棒的点数清零。释放能量有施法间隔cdcd 是正整数),即相邻的两次释放的时间间隔至少有cd 秒。任何时刻当hp≤0 时视为死亡,问这个英雄存活下来的前提下, cd 的值最大可以是多少?</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">注意,若a[i]为负,受到伤害后实际上生命值是增加的,魔棒仍然积攒能量。</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行两个正整数 nhp,含义如题目所述。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第二行 n 个整数,分别是a[i]..a[n]</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一个数,最大的 cdcd 是正整数。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">如果 cd 没有上限,输出“No upper bound.”;如果无论如何都不能存活,输出-1</span></p> <p></p> <p></p>

【输入样例】 7 30 20 5 30 4 10 5 20 20

【输出样例】 2

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 30%的数据,有n≤12</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 100%的数据,有n≤500|a[i]|≤1000</span></p> <p></p> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

1

0

1712

2011NOI导刊_09】采药(medic.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">辰辰是个天资聪颖的孩子,他的梦想是成为世界上最伟大的医师。为此,他想拜附近最有威望的医师为师。医师为了判断他的资质,给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说:孩子,这个山洞里有一些不同的草药,采每一株都需要一些时间,每一株也有它自身的价值。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">我会给你一段时间,在这段时间里,你可以采到一些草药。如果你是一个聪明的孩子,你应该可以让采到的草药的总价值最大。”</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">如果你是辰辰,你能完成这个任务吗?</span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入的第一行有两个整数 n m,用一个空格隔开。m 代表总共能够用来采药的时间,n 代表山洞里的草药的数目。接下来的n 行每行包括两个整数,分别表示采摘某株草药的时间Ti 和这株草药的价值Vi</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输出包括一行,这一行只包含一个整数,表示在规定的时间内,可以采到的草药的最大总价值。</span></p> <p></p> <p></p>

【输入样例】 3 9 10 10 8 1 1 2

【输出样例】 3

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 50%的数据,n,m≤1000</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 100%的数据,n,m≤100000Ti,Vi≤10</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

3

0

1713

2011NOI导刊_09】方格取数(matrix.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">给定一个 n×m 的矩阵,记录左上角为(1,1),右下角为(n,m),现在从(1,1)开始取数,每次只能向下或向右移动一个单位,最终到达(n,m),我们把路径上所有的数相乘,结果记为C。使C 的结果最大已经不能满足我们了,现在我们想让C 末尾的零个数最少。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">PS. 11000 末尾有三个零,100000100 末尾有两个零。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行是两个正整数 n m,表示矩阵大小。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">接下来 n 行每行m 个正整数,给出了整个矩阵。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一个整数:最少的零的个数。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例】 3 3 1 2 3 10 5 100 10 8 9

【输出样例】 1

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"> 30%的数据有:n,m≤5</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"> 100%的数据有:1<n,m≤1000,所有输入数据不超过32 位整数范围。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

2

0

1714

2011NOI导刊_09】统计(count.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于排列(P1,P2,P3,…Pn),定义(i,j)为逆序对当且仅当i<j Pi>Pj。统计{1,2,3,…,n}的所有排列中,逆序对数量为m 的排列个数。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">仅一行,两个正整数 nm</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">仅一个整数,表示满足条件的排列个数对 124567 取模。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例】 3 1

【输出样例】 2

0

<div>【数据规模】</div> <div>对于 30%的数据,有n≤10</div> <div>对于 100%的数据,有0<n,m≤1000</div> <div></div> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

2

0

1715

2011NOI导刊_07】高中运动会(match.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">梦幻城市每年为全市高中生兴办一次运动会。为促使各校同学之间的交流,采用特别的分队方式:每一个学校的同学,必须被均匀分散到各队,使得每一队中该校的人数皆相同。为增加比赛的竞争性,希望分成越多队越好。你的任务是由各校的人数决定最多可以分成的队数。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行一个正整数n ,代表学校的个数。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">接下来n 行,每行一个正整数,分别代表这n 个学校的人数。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">最多可分成的队数。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例1 3 12 16 20 【输入样例2 4 400 200 150 625

【输出样例1 4 【输出样例2 25

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 100%的数据,n≤500,每个学校人数最多10000</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

2

0

1716

2011NOI导刊_07】周年纪念日(anniversary.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">长郡中学校长打算举行建校 100 周年的晚会。学校的职员是分等级的,也就是说职员之间的上下级关系组成一棵以校长为树根的树。校长要亲自邀请一些职员参见晚会。同时校长亲自到场欢庆这个节日。职员用1n 之间的整数编号,人事处给出了每个职员的搞笑指数。如果一个人和他上司一起参加,那么便可能产生麻烦。为了使晚会的每个参加者都高兴,校长不会同时邀请某个职员和他的顶头上司。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">你的任务是给出一个客人列表,使得客人的搞笑指数之和最大。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行一个整数 n1≤n≤6000)。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">以下 n 行每行是相应编号职员的搞笑指数,该数的返回是[-128..127]</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">然后是职员的关系树,每行格式是<x> <y>,意思是第y 个职员是第x 个职员的顶头上司。输入以0 0 结束。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">最大的搞笑指数之和。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例】 7 1 1 1 1 1 1 1 1 3 2 3 6 4 7 4 4 5 3 5 0 0

【输出样例】 5

0

 

 

2017-04-16 09:36:29

1

128

N

0

1

0

1717

2011NOI导刊_07】智力游戏(game.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">小华最近迷上了一个你小时候已经玩厌了的游戏:移火柴棒。他现在吵着要你陪他玩,你没办法,只好写一个程序来完成这个工作了。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">你被给出了一个火柴拼成的等式,比如下面这个:</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <a href="/JudgeOnline/admin/../upload/pimg1717_1.jpg" rel="lightbox[739]" style="outline: none; color: rgb(110, 161, 219); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><img alt="" src="/JudgeOnline/admin/../upload/pimg1717_1.jpg" style="border: none; height: auto; max-width: 100%; width: auto;" /><br /> </a><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">它显然是不成立的,但是我们可以通过移动一个其中的火柴使得它成立。变成如下一个等式:</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <a href="/JudgeOnline/admin/../upload/pimg1717_2.jpg" rel="lightbox[739]" style="outline: none; color: rgb(110, 161, 219); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><img alt="" src="/JudgeOnline/admin/../upload/pimg1717_2.jpg" style="border: none; height: auto; max-width: 100%; width: auto;" /><br /> </a><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">现在给出一个类似的等式,请问,最少移动多少根火柴可以使得它变成一个成立的等式?</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">每个数字的表示方法如下:我们用 7 根火柴表示每一个数字。火柴编号06,如下图:</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <a href="/JudgeOnline/admin/../upload/pimg1717_3.jpg" rel="lightbox[739]" style="outline: none; color: rgb(110, 161, 219); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><img alt="" src="/JudgeOnline/admin/../upload/pimg1717_3.jpg" style="border: none; height: auto; max-width: 100%; width: auto;" /><br /> </a><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">每一个数字都可以用对应的火柴组成的集合表示:</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">0{0,1,2,4,5,6}</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">1{2,5} or {1,4} </span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">2{0,2,3,4,6}</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">3{0,2,3,5,6} </span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">4{1,2,3,5}</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">5{0,1,3,5,6} </span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">6{0,1,3,4,5,6}</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">7{0,2,5}</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">8{0,1,2,3,4,5,6}</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">9{0,1,2,3,5,6} </span></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入有三个数字,分别表示上面的表达式中的从左到右的三个数字,每个数都在 0999 之间。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输出只需一个数,表示使等式成立最少需要移动的火柴数,不允许改变位数以及符号,不要制造0开头的数。</span></p> <p></p> <p></p>

【输入样例】 5 7 7

【输出样例】 1

0

 

 

2017-04-16 09:36:29

1

128

N

0

0

0

1718

2011NOI导刊_07】引爆炸弹(bomb.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"> n 个炸弹,有些炸弹牵了一根单向引线(也就是说引线只有在这一端能被炸弹点燃),只要引爆了这个炸弹,用引线连接的下一个炸弹也会爆炸。每个炸弹还有个得分,当这个炸弹被引爆后就能得到相应得分。现在要你引爆k 个炸弹,使得得分最大。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行两个整数 nk</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">接下来的 n 行,每行两个整数a[i]b[i]a[i]表示这个炸弹用引线连接的下一个炸弹,如果a[i]0,则表示这个炸弹没有连接引线。b[i]表示这个炸弹的得分。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">最多可分成的队数。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例1 8 2 0 1 1 1 2 100 2 100 0 1 5 1 6 2 6 2 【输入样例2 10 1 0 1 1 1 2 100 2 104 0 1 5 1 6 2 6 2 3 10 8 105

【输出样例1 202 【输出样例2 112

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">1≤b[i]≤1000000</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 30%的数据,n≤1000k≤30</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 60%的数据,n≤50000k≤100</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于 100%的数据,n≤200000k≤500</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

1

0

1719

2011NOI导刊_07】取石子(stone.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"> n 个石子围成一圈,每个石子都有一个权值a[i]。给你一次且仅一次取石子的机会,取石子的块数不限,取完后统计得分。现在要使取出的石子得分最大。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">每个石子的得分计算公式是a[i]*dd 表示这个石子到两边被取了的石子的距离和。如{1,2,7,9,8,6,4,5,3,10}这些权值的石子围成一圈,不同取法有不同得分:</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <a href="/JudgeOnline/admin/../upload/pimg1719_1.jpg" rel="lightbox[739]" style="outline: none; color: rgb(189, 201, 0); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><img alt="" src="/JudgeOnline/admin/../upload/pimg1719_1.jpg" style="border: none; height: auto; max-width: 100%; width: auto;" /></a></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行一个整数 n</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">接下来 n 行,每行一个整数a[i]</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">仅一个整数,表示最大得分。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例】 5 1 2 3 4 20

【输出样例】 80 【数据规模】 1≤a[i]≤100000 对于 30%的数据,n≤60; 对于 60%的数据,n≤300; 对于 100%的数据,n≤100000

0

 

 

2017-04-16 09:36:29

1

128

N

0

0

0

1720

2011NOI导刊_07】化工厂装箱员(worker.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">118号工厂是世界唯一秘密提炼锎的化工厂,由于提炼锎的难度非常高,技术不是十分完善,所以工厂生产的锎成品可能会有3种不同的纯度,A100%B1%C0.01%,为了出售方便,必须把不同纯度的成品分开装箱,装箱员grant1次顺序从流水线上取10个成品(如果一共不足10个,则全部取出),以后每一次把手中某种纯度的成品放进相应的箱子,然后再从流水线上顺序取一些成品,使手中保持10个成品(如果把剩下的全部取出不足10个,则全部取出),如果所有的成品都装进了箱子,那么grant的任务就完成了。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">由于装箱是件非常累的事情,grant希望他能够以最少的装箱次数来完成他的任务,现在他请你编个程序帮助他。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">1行为n1<=n<=100),为成品的数量以后n行,每行为一个大写字母ABC,表示成品的纯度。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">仅一行,为grant需要的最少的装箱次数。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例】 11 A B C A B C A B C A B

【输出样例】 3

0

 

 

2017-04-16 09:36:29

1

128

N

0

0

0

1721

2011NOI导刊_10】词编码(word.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一个发送机可以通过一条隧道发送一些以二进制代码组成的单词。在其尽头的接受机可以使用特殊技术恢复到最初的单词。每个单词最初都由01组成。所有的单词最初长度都为n(4<=n<=1000)。当穿过隧道之后单词可能发生以下几种情况之一:</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">(1)任意一个01取代</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">(2)任意一个符号被删除</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">(3)一个符号(01)被插入到任何位置</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">(4)不改变</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">我们知道最初的单词都具有以下性质:有1的位置号的总和是n+1的倍数,或者是0</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">n和转换后的单词,每个单词占一行。单词数不大于2001,不会有其他任何东西,除了一些空格与空行。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">你的程序应该打印输出原始序列的词,注意换行。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">若有多解,操作4优先,不行则按操作1,2,3优先。同一操作,按操作位置最先的优先(从左到右数起1,2,3,…n),还有操作2时,被删数列,先在被删数列添0,不行再添1</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">如果没答案输出-1</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例】 4 0000 011 1011 11011

【输出样例】 0000 0110 1001 1111

0

 

 

2017-04-16 09:36:29

1

128

N

0

0

0

1722

2011NOI导刊_10】笨笨粉刷匠(draw.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【题目描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">笨笨太好玩了,农田荒芜了,彩奖用光了,笨笨只好到处找工作,笨笨找到了一份粉刷匠的工作。笨笨有n条木板需要被粉刷。每条木板被分成m个格子,每个格子要被刷成红色或蓝色。笨笨每次粉刷,只能选择一条木板上一段连续的格子,然后涂上一种颜色,已知每个格子最多只能被粉刷一次。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">如果笨笨只能粉刷t次,他最多能正确粉刷多少格子。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一个格子如果未被粉刷或被粉刷成错误颜色,就算粉刷错误。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行三个数nmt</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">接下来n行,每行一个长度为m的字符“0”表示红色,"1"表示蓝色。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一个整数,最多能正确粉刷的格子数。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例】 3 6 3 111111 000000 001100

【输出样例】 16

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据范围】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">100%数据范围满足1≤nm≤500≤t≤2500</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

2

0

1723

2011NOI导刊_10】笨笨的电话网络(phone.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【题目描述】 </span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">多年以后,笨笨长大了,成为电话线布置师。由于地震使得某市的电话线全部损坏,笨笨是负责接到震中市的负责人。该市周围分布着N(1 <= N <= 1000)根据序号1…n顺序编号的废弃电话杆,任意两根电线杆之间没有电话线连接,一共有p(1 <= p <= 10000)对电线杆可以拉电话线。其他的由于地震使得无法连接。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">i对电线杆的两个端点分别是aibi,他们的距离为li(1 <= li <= 1000000)。数据中每对(aibi)只出现一次。编号为1的电线杆已经接入了全国的电话网络,整个使得电话线全部练到了编号N的电线杆上。也就是说,笨笨的任务仅仅是找一条将1号和N号电线杆连起来的路径,其余的电线杆并不一定要连入电话网络,</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">电信公司决定支援灾区免费为此市连接k0 <= k <= n)对由笨笨指定的电线杆,对于此外的那些电话线,需要为他们付费,总费用取决于其中最长的电话线的长度(每根电话线仅连接一对电线杆)。如果需要连接的电线杆不超过k对,那么费用支出为0</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">请你计算一下,将电话线引到震中市需要在电话线上花多少钱?</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入文件的第一行包含数字n,p,k</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第二行到第p+1行,每行分别都为三个整数aibili</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一个整数,表示该项工程的最小支出,如果不可能完成则输出-1 </span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例】 5 7 1 1 2 5 3 1 4 2 4 8 3 2 3 5 2 9 3 4 7 4 5 6

【输出样例】 4

0

 

 

2017-04-16 09:36:29

1

128

N

0

1

0

1724

2011NOI导刊_11】多米诺骨牌(domino.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Jzabc 对多米诺骨牌有很大兴趣,然而他的骨牌比较特别,只有黑色的和白色的两种。他觉得如果存在连续三个骨牌是同一种颜色,那么这个骨牌排列便是不美观的。现在他有n 个骨牌要排列,他想知道不美观的排列的个数,由于数字较大,数学不好的他不会统计,所以他请你来帮忙。希望你在一秒内求出不美观的排列的个数。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">只有一个正整数,即要排列的骨牌个数</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一个数,即不美观的排列个数。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例】 4

【输出样例】 6

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Hint</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">有六种不美观的排列:</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">黑黑黑黑,白白白白,黑黑黑白,白白白黑,黑白白白,白黑黑黑</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据范围】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">20%的数据,n≤60</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">50%的数据,n≤600</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">100%的数据,n≤20000</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

0

0

1725

2011NOI导刊_11】最小奖励(minaw.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Jzabc 更是一个狂热的旅游爱好者。这次他想去一个诡异的地方。这个地方有n 个村庄,编号为1 n。此刻他在1 号村庄,他想去n 号村庄。这n 个村庄之间有m 条单向道路。通过某些道路时,可能会花费一些钱作为买路钱,可是通过一些道路时,不仅不需要交买路钱,而且会得到一些奖励(这就是诡异的地方?)。当然两个村庄之间可能有多条直接相连的道路,但是每一条道路只能通过一次。这些村庄有这样的特性,从任何一个村庄出发,沿着任一条路径走都不会回到出发点。找到一条路径从1 号村庄到n 号村庄后,他需要计算一共得到多少奖励,一共交了多少买路钱。如果得到的总奖励钱数大于交的买路钱数,那么称走这一条路径可以得到奖励;相反,如果前者小于后者,那么称走这一条路径需要花费。如果两者相等,那么Jzabc 不会选这一条路(我也不知道他为什么不选这一条路径)。不会出现所有的路径两者都相等。他又需要你的帮助,让你找一条路径,使他得到的奖励最小(为什么不是最大的奖励?),并输出最小奖励。如果找不到一条路径能使他得到奖励,那么就找一条路径使他得到的花费最大(为什么就不是最小的花费?),并输出最大花费。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行两个正整数 n mn 是村庄数,m 是道路数。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">以下m 行,每行三个数x,y,w,表示x 为起点,y 是终点,若w 为正,则是通过此条道路得到的奖励;若w 为负,则是通过此条道路交的买路钱w≠0 |w|≤10</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一个整数。若有最小奖励,则输出。否则输出最大花费。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例1 3 4 1 2 2 2 3 -1 2 3 3 1 3 -1 【输入样例2 3 4 1 2 2 2 3 -3 2 3 -5 1 3 -2

【输出样例1 1 【输出样例2 3

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">20%的数据,n≤20m≤200</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">50%的数据,n≤50m≤2000</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">100%的数据,n≤100m≤20000</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

2

0

1726

2011NOI导刊_11】超车(overtaking.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">Jzabc 除了对多米诺骨牌感兴趣外,对赛车也很感兴趣。上个周末他观看了一场赛车比赛。他总是能想出许多稀奇的问题。某一时刻,他看到有n 辆车(总是匀速行驶)在同一直线上,并且处在一个无限长度的直道上。而且n 辆车有严格的先后之分。他通过特殊的器材测出了每一辆车的速度。那么问题出现了,如果有两辆车A 车和B 车,A 车在B 车的后面,并且A 车的速度比B 车快,那么经过一段时间后,A 车一定会超过B 车。我们称之为一次超车。那么他想请你帮忙计算超车总数。我们记车道起点的坐标为0,没有两辆车的坐标相同。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行,一个数 n,车辆总数。以下n 行为n 辆车的信息:</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第二行至第 n+1 行,每行两个正整数x,y,分别表示车的坐标和车的速度。0<x,y≤1000000000</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一行,超车总数。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例】 2 5 6 2 8

【输出样例】 1

0

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【数据规模】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">20%的数据,n≤300</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">50%的数据,n≤3000</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">100%的数据,n≤300000</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

1

0

1727

2011NOI导刊_12】阅览室(reading.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一个阅览室每天都要接待大批读者。阅览室开门时间是0,关门时间是T。每位读者的到达时间都不一样,并且想要阅读的刊物不超过5 本。每位读者心里对自己想看的刊物都有一个排位,到达之后他会先去找自己最想看的刊物,如果找不到则去找其次想看的刊物。如果找不到任何他想看的刊物,他会开始等待,直到有一本以上的他想看的刊物被人放回原处。当然,他会先去拿其中自己最想看的刊物。当他看完某一本刊物后,就把它放回原处,接着去找自己没看过的最想看的刊物。如此下去,直到看完所有他想看的刊物为止。矛盾出现在两个人同时想要拿同一本刊物的时候。阅览室为了避免读者之间出现争执,作了一个规定,读者每次在开始等待时先去服务台做一次登记。如果两个人都同时想要一本刊物,那么先登记的读者将得到这本刊物。如果两个人同时登记,那么先到达阅览室的读者将得到刊物。没得到的人就只能去找其他的刊物看。阅览室关门时,所有读者都将被强迫离开阅览室,不再允许继续阅读。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">现在阅览室想做一个统计调查,你被要求写一个程序来模拟这个过程计算出所有刊物被阅读的总次数。当某个读者开始阅读某本刊物时,该刊物的被阅读次数就加1,无论这本刊物最后有没有被读完。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入包括了多个测试数据。每个测试数据开头是两个整数T n1≤n≤100),分别表示图书馆关门时间和读者总数。接下来按照读者的到达时间先后依次给出了每位读者的具体描述。每个读者描述开头是一个整数t0≤t<T),表示该读者到达时间。接下来一行开头是一个整数k1≤k≤5),表示该读者想要看的刊物数目。之后跟着2k 个整数按照读者想要阅读的刊物的顺序依次给出了刊物的描述。其中第2i-1 个整数表示刊物的编号s0≤s<1000),第2i 个整数表示该读者读完这本刊物所需的时间。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于每个测试数据,在单独一行里输出所有刊物被阅读的总次数。</span></p> <p></p>

【输入样例】 10 4 1 2 1 4 2 5 3 1 2 4 7 3 2 2 1 3 3 2 9 1 4 2

【输出样例】 5

0

 

 

2017-04-16 09:36:29

1

128

N

0

0

0

1728

2011NOI导刊_12】影像之结构化特征(graph.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">在影像比对中,有一种方法是利用影像中的边缘(edge)资讯,计算每个边缘资讯中具有代表性的结构化特征,以作为比对两张影像是否相似的判断标准。 Water-filling 方法是从每个边缘图的一个端点开始,绕着相连的边缘点走并依序编号。若走到某一步时,遇到一个以上不同的连接点,则分成不同路径同时继续走,直到没有任何连接点为止。如果一个点和另一个点为左右相邻或上下相邻,就称为连接。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <a href="/JudgeOnline/admin/../upload/pimg1728_1.jpg" rel="lightbox[793]" style="outline: none; color: rgb(110, 161, 219); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><img alt="" src="/JudgeOnline/admin/../upload/pimg1728_1.jpg" style="border: none; height: auto; max-width: 100%; width: auto;" /></a><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">例如,在图一的影像中包含三个边缘图,每个边缘图由一些互相连接的边缘点构成。图中以黑色的方块代表边缘点,白色的方块代表背景。在Water-filling 方法中,首先,从第一行(row)开始,由左至右,由上至下,先找到第一个黑点并编号为1。接着,找1 的下一个尚未编号的连接点并编号为2。依此方法继续往下一个点前进并依序编号。在编号6 的点之后有两个尚未编号的连接点,此时,则分为两条路线,并同时编号为7 继续往下走。当走到没有任何的相连点时,则结束现有边缘图的编号,并继续对影像中的其它边缘图编号。走完图一所有边缘图后所得到的编号如图二所示。所以,走完这三个边缘图所需要的步数分别为127 3;因此,127 3 可以作为代表此张影像的结构化特征。请注意:位于斜对角上的两点不能算做连接。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">请写一个程序计算每个影像中,以Water-filling 方法走完其中所有的边缘图后,将每个边缘图所需走的步数输出。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">输入文件包含一个正方形的影像。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">第一行是 n1≤n≤1000),表示正方形的规模。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">接下来的 n n 列表示影像内容:0 表示背景的白点,1 表示黑色的边缘点。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于每个输入的影像,以Water-filling 方法走完所有的边缘图后,先输出此影像中共有几个边缘图。然后按升序方式输出每个边缘图所需走的步数。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例1 10 0000000000 0011110000 0000010000 0011111000 0010110100 0010010110 0011110010 0100010010 0100000110 0100000000 【输入样例2 9 000000011 111111101 100000101 111111101 100010101 100010101 111111101 000000001 000000011

【输出样例1 3 3 7 12 【输出样例2 2 11 12

0

 

 

2017-04-16 09:36:29

1

128

N

0

1

0

1729

2011NOI导刊_12】诸侯安置(empire.cpp/pas/c

<p style="margin: 0px 0px 1em; padding: 0px; line-height: 27px; color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px;">【问题描述】</p> <p style="margin: 0px 0px 1em; padding: 0px; line-height: 27px; color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px;">很久以前,有一个强大的帝国,它的国土成正方形状,如图所示。<br /> <a href="/JudgeOnline/admin/../upload/pimg1729_1.jpg" rel="lightbox[793]" style="outline: none; color: rgb(110, 161, 219);"><img alt="" src="/JudgeOnline/admin/../upload/pimg1729_1.jpg" style="border: none; height: auto; max-width: 100%; width: auto;" /></a><br /> 这个国家有若干诸侯。由于这些诸侯都曾立下赫赫战功,国王准备给他们每人一块封地(正方形中的一格)。但是,这些诸侯又非常好战,当两个诸侯位于同一行或同一列时,他们就会开战。如下图为n3 时的国土,阴影部分表示诸侯所处的位置。前两幅图中的诸侯可以互相攻击,第三幅则不可以。<br /> <a href="/JudgeOnline/admin/../upload/pimg1729_2.jpg" rel="lightbox[793]" style="outline: none; color: rgb(110, 161, 219);"><img alt="" src="/JudgeOnline/admin/../upload/pimg1729_2.jpg" style="border: none; height: auto; max-width: 100%; width: auto;" /></a><br /> 国王自然不愿意看到他的诸侯们互相开战,致使国家动荡不安。因此,他希望通过合理的安排诸侯所处的位置,使他们两两之间都不能攻击。<br /> 现在,给出正方形的边长n,以及需要封地的诸侯数量k,要求你求出所有可能的安置方案数。(n≤l00k≤2n2-2n+1)<br /> 由于方案数可能很多,你只需要输出方案数除以504 的余数即可。</p> <p style="margin: 0px 0px 1em; padding: 0px; line-height: 27px; color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px;"></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">仅一行,两个整数 n k,中间用一空格隔开。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">一个整数,表示方案数除以 504 的余数。</span></p> <p></p> <p></p>

【输入样例】 2 2

【输出样例】 4

0

<p style="margin: 0px 0px 1em; padding: 0px; line-height: 27px; color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px;">Hint<br /> 四种安置方案如图 2-4 所示。注意:镜面和旋转的情况属于不同的方案。<br /> <a href="/JudgeOnline/admin/../upload/pimg1729_3.jpg" rel="lightbox[793]" style="outline: none; color: rgb(189, 201, 0);"><img alt="" src="/JudgeOnline/admin/../upload/pimg1729_3.jpg" style="border: none; height: auto; max-width: 100%; width: auto;" /></a></p> <p></p>

 

2017-04-16 09:36:29

1

128

N

0

0

0

1730

2011NOI导刊_13】最多因子数(divisors.cpp/pas/c

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【问题描述】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">数学家们喜欢各种类型的有奇怪特性的数。例如,他们认为945 是一个有趣的数,因为它是第一个所有约数之和大于本身的奇数。</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">为了帮助他们寻找有趣的数,你将写一个程序扫描一定范围内的数,并确定在此范围内约数个数最多的那个数。不幸的是,这个数和给定的范围的都比较大,用简单的方法寻找可能需要较多的运行时间。所以请确定你的算法能在几秒内完成最大范围内的扫描。</span></p> <p></p> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输入】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">只有一行,给出扫描的范围,由下界 L 和上界U 确定。满足2≤L≤U≤1000000000</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

<p><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">【输出】</span><br style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;" /> <span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;">对于给定的范围,输出该范围内约数个数 D 最多的数P。若有多个,则输出最小的那个。请输出“Between L and UP has a maximum of D divisors,其中LUP D 的含义同前面所述。</span></p> <div><span style="color: rgb(102, 102, 102); font-family: 'LiSong Pro', Helvetica, Arial, sans-serif; font-size: 15px; line-height: 27px;"><br /> </span></div> <p></p>

【输入样例】 1000 2000

【输出样例】 Between 1000 and 2000, 1680 has a maximum of 40 divisors.

0

 

 

2017-04-16 09:36:29

1

128

N

0

0

0

1731

【动态规划】数塔

<p style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;"> 有如图数塔,从顶部出发,在每一节点选择向左走或向右走,一直走到底。要求找到一个路径,使路径总和最大。<br />                                13<br />                           11       8<br />                      12       7      26<br />                   6      14      15      8<br />             12      7      13      24     11 </p>

<p style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;"> 第一行输入一正整数n<br /> 接下来从第2行到第n+1行每行输入行数减1个正整数m </p>

<p style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;"> 共一行<br /> 输出最大总和,格式参考样例输出; </p>

5 13 11 8 12 7 26 6 14 15 8 12 7 13 24 11

max=86

0

 

(改)Codevs_4979:数塔

2017-06-03 20:38:04

1

128

N

36

73

0

1737

【栈】表达式括号匹配(stack)

<p class="MsoNormal" style="text-indent:21pt;"> <span style="font-family:宋体;"><span>假设一个表达式有英文字母(小写)、运算符(</span></span><span style="font-family:'Times New Roman';">+</span><span style="font-family:宋体;"><span></span>—</span><span style="font-family:'Times New Roman';">*</span><span style="font-family:宋体;"><span></span></span><span style="font-family:'Times New Roman';">/</span><span style="font-family:宋体;"><span>)和左右小(圆)括号构成,以</span>“</span><span style="font-family:'Times New Roman';">@</span><span style="font-family:宋体;">”作为表达式的结束符。</span> </p> <p class="MsoNormal" style="text-indent:21pt;"> <span style="font-family:宋体;">请编写一个程序检查表达式中的左右圆括号是否匹配,若匹配,则返回“</span><span style="font-family:'Times New Roman';">YES</span><span style="font-family:宋体;">”;否则返回“</span><span style="font-family:'Times New Roman';">NO</span><span style="font-family:宋体;">”。表达式长度小于 </span><span style="font-family:'Times New Roman';">255</span><span style="font-family:宋体;"><span>,左圆括号少于</span> </span><span style="font-family:'Times New Roman';">20</span><span style="font-family:宋体;"> <span>个。</span></span><span style="font-family:宋体;"></span> </p>

<p class="MsoNormal" style="margin-left:18pt;"> <span style="font-size:10.5pt;font-family:宋体;"><span>输入文件</span> </span><span style="font-size:10.5pt;font-family:'Times New Roman';">stack.in</span><span style="font-size:10.5pt;font-family:宋体;"> <span>包括一行数据,即表达式。</span></span> </p>

<p class="MsoNormal"> <span style="font-size:10.5pt;font-family:宋体;"><span>输出文件</span> </span><span style="font-size:10.5pt;font-family:'Times New Roman';">stack.out</span><span style="font-size:10.5pt;font-family:宋体;"> <span>包括一行,即</span>“</span><span style="font-size:10.5pt;font-family:'Times New Roman';">YES</span><span style="font-size:10.5pt;font-family:宋体;">” “</span><span style="font-size:10.5pt;font-family:'Times New Roman';">NO</span><span style="font-size:10.5pt;font-family:宋体;">”</span> </p>

(25+x)*(a*(a+b+b)@

NO

0

 

一本通:p400

2017-06-03 20:25:45

1

128

N

15

20

0

1732

【动态规划】最长不下降序列

<p> 有由n个不相同的整数组成的数列,记为a(1)a(2)...a(n),i!=j时,a(i)!=a(j)。若存在i1 < i2 < i3 < ... < ie,且有a(i1) <= a(i2) <= ... < =a(ie), 则称为长度为e的不下降序列。如 318714101223411624 则有3182324是一个长度为4的不下降子序列 3710122324是长度为6的不下降子序列。现要求你求最长的不下降子序列。 </p> <p>         如果存在多个长度相同的序列,则输出最靠前的那个序列,如题中<span>这组数据存在两个长度为6的序列,其中子序列:</span><span>3710122341长度同样为6,并且位置靠前,因此是这组数据的问题解</span> </p>

<p> 输入多个整数 (1 <= n <= 1000) </p> <p> <br /> </p>

<div class="content"> 输出最长不下降子序列及其长度。 </div>

300 250 275 252 200 138 245

max=2 250 275

0

 

 

2017-06-03 20:37:53

1

128

N

28

100

0

1733

【动态规划】陈修远の烦恼(移动公司)

<p> 下图表示城市之间的网络路线,线段上的数字表示网络延迟,单向通行由<span>A(修远家)->E(DotA游戏服务器)</span>。求<span><span>A(修远家)->E(DotA游戏服务器)</span></span>的最小延迟。 </p> <p> <img src="/JudgeOnline/upload/image/20170506/20170506223514_18996.png" alt="" /> </p>

<span style="color:#333333;font-family:'Helvetica Neue', Helvetica, Arial, sans-serif;font-size:14px;line-height:16.6667px;background-color:#EEEEEE;">第一行一个整数nn不超过20,表示城市的数目。 此后的n行,每行n个整数。第xy列的整数表示从第x台城市到第y城市的网络延迟。</span>

输出从第1个城市出发到第n个城市的最短路径长度及最短路径。

10 0 2 5 1 0 0 0 0 0 0 0 0 0 0 12 14 0 0 0 0 0 0 0 0 6 10 4 0 0 0 0 0 0 0 13 12 11 0 0 0 0 0 0 0 0 0 0 3 9 0 0 0 0 0 0 0 0 6 5 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0

minlong=19 1 3 5 8 10

0

听说修远家里换了移动网络,移动千兆,DotA不能233

233333

2017-06-03 20:37:43

1

128

N

10

24

0

1734

【动态规划】挖地雷

在一个地图上有N个地窖(N<=200),每个地窖中埋有一定数量的地雷。同时,给出地窖之间的连接路径,并规定路径都是单向的,且保证都是小序号地窖指向大序号地窖,也不存在可以从一个地窖出发经过若干地窖后又回到原来地窖的路径,某人可以从任一处开始挖地雷,然后可以沿着指出的连接往下挖(仅能选择一条路径),当无连接时挖地雷工作结束。设计一个挖地雷的方案,使某人能挖到最多的地雷。

N(表示地窖的个数)<br /> w1  w2  ··  wn(表示每个地窖中埋藏的地雷数量)<br /> x1  y1 (表示从x1可到y1x1<y1<br /> x2  y2<br /> ···<br /> 0 0    (表示输入结束)<br />

 K1-K2-···<span style="line-height:15px;">-</span>KV         (挖地雷的顺序)<br />  max                         (最多挖出的地雷数量)<br />

6 5 10 20 5 4 5 1 2 1 4 2 4 3 4 4 5 4 6 5 6 0 0

3-4-5-6 34

0

 

NOIP_1996.TG3:挖地雷

2017-06-03 20:36:59

1

128

N

13

27

0

1735

【动态规划】友好城市

Palmia国有一条横贯东西的大河,河有笔直的南北两岸,岸上各有位置各不相同的N个城市。北岸的每个城市有且仅有一个友好城市在南岸,而且不同城市的友好城市不相同。<br /> 每对友好城市都向政府申请在河上开辟一条直线航道连接两个城市,但是由于河上雾太大,政府决定避免任意两条航道交叉,以避免事故。编程帮助政府做出一些批准和拒绝申请的决定,使得在保证任意两条航线不相交的情况下,被批准的申请尽量多。<br />

1行,一个整数N(1<=N<=5000),表示城市数。<br /> 2行到第n+1行,每行两个整数,中间用1个空格隔开,分别表示南岸和北岸的一对友好城市的坐标。(0<=xi<=10000)<br />

对于每组测试数据,仅一行,输出一个整数,表示政府所能批准的最多申请数。<br />

7 22 4 2 6 10 3 15 12 9 8 17 17 4 2

4

0

 

 

2017-06-03 20:36:44

1

128

N

11

18

0

1736

【动态规划】机器分配

总公司拥有高效设备M台,准备分给下属的N个分公司。各分公司若获得这些设备,可以为国家提供一定的盈利。问:如何分配这M台设备才能使国家得到的盈利最大?求出最大盈利值。其中M≤15N≤10。分配原则:每个公司有权获得任意数目的设备,但总台数不超过设备数M <br />

输入数据文件格式为:第一行有两个数,第一个数是分公司数N,第二个数是设备台数M <br /> 接下来是一个N*M的矩阵,表明了第 I个公司分配 J台机器的盈利。<br /> <br />

输出第一行为最大盈利值; <br /> 接下来有n行,分别为各分公司分配的机器数。<br />

3 3 30 40 50 20 30 50 20 25 30

70 {最大盈利值为70} 1 1 {第一分公司分1} 2 1 {第二分公司分1} 3 1 {第三分公司分1}

0

 

 

2017-06-03 20:36:34

1

128

N

5

10

0

1738

【栈】括弧匹配检验(check)

<p class="MsoNormal" style="text-indent:21pt;"> <span style="font-size:9.5pt;font-family:宋体;"><span>假设表达式中允许包含两种括号:圆括号和方括号,其嵌套的顺序随意,如([</span> <span>]())或[([</span> <span>][</span> <span>])]等为正确的匹配,[(</span> <span>])或([</span> <span>](</span> <span>)或</span> </span><span style="font-size:9.5pt;font-family:'Times New Roman';">( ( ) )</span><span style="font-size:9.5pt;font-family:宋体;"> <span>)均为错误的匹配。</span></span><span style="font-size:9.5pt;font-family:宋体;"></span> </p> <p class="MsoNormal" style="margin-left:21pt;"> <span style="font-size:10.5pt;font-family:宋体;"><span>现在的问题是,要求检验一个给定表达式中的括弧是否正确匹配?</span></span><span style="font-size:10.5pt;font-family:宋体;"></span> </p> <p class="MsoNormal"> <span style="font-size:12pt;font-family:'Times New Roman';"></span> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21pt;" align="justify"> <span style="font-size:10.5pt;font-family:宋体;"><span>输入一个只包含圆括号和方括号的字符串,判断字符串中的括号是否匹配,匹配就输出</span> </span><span style="font-size:10.5pt;font-family:'Times New Roman';">“OK” </span><span style="font-size:10.5pt;font-family:宋体;"><span>,不匹配就输出</span></span><span style="font-size:10.5pt;font-family:'Times New Roman';">“Wrong”</span><span style="font-size:10.5pt;font-family:宋体;"><span>。输入一个字符串:[([][])],输出:</span></span><span style="font-size:10.5pt;font-family:'Times New Roman';">OK</span><span style="font-size:10.5pt;font-family:'Times New Roman';"></span> </p>

<p class="MsoNormal" style="margin-left:21pt;"> <span style="font-size:10.5pt;font-family:宋体;"><span>输入仅一行字符(字符个数小于</span> </span><span style="font-size:10.5pt;font-family:'Times New Roman';">255</span><span style="font-size:10.5pt;font-family:宋体;"><span></span></span> </p> <p class="MsoNormal" style="margin-left:21pt;"> <span style="font-size:10.5pt;font-family:宋体;"><span></span></span><span style="font-size:10.5pt;font-family:宋体;"></span>  </p>

<p class="MsoNormal" style="margin-left:21pt;"> <span style="font-size:10.5pt;font-family:宋体;"><span>匹配就输出</span> </span><span style="font-size:10.5pt;font-family:'Times New Roman';">“OK”</span><span style="font-size:10.5pt;font-family:宋体;"> <span>,不匹配就输出</span></span><span style="font-size:10.5pt;font-family:'Times New Roman';">“Wrong”</span><span style="font-size:10.5pt;font-family:宋体;"><span></span></span> </p> <p class="MsoNormal" style="margin-left:21pt;"> <span style="font-size:10.5pt;font-family:宋体;"><span></span></span><span style="font-size:10.5pt;font-family:宋体;"></span>  </p>

[(])

Wrong

0

 

一本通:P400

2017-06-03 20:26:01

1

128

N

27

106

0

1739

【栈】字符串匹配问题

字符串中只含有括号 (),[],<>,{},判断输入的字符串中括号是否匹配。如果括号有互相包含的形式,从内到外必须是<>,(),[],{},例如。输入: [()] 输出:YES,而输入([])([)]都应该输出NO

文件的第一行为一个整数n,表示以下有多少个由括好组成的字符串。接下来的n行,每行都是一个由括号组成的长度不超过255的字符串。

在输出文件中有n行,每行都是YESNO

5 {}{}<><>()()[][] {{}}{{}}<<>><<>>(())(())[[]][[]] {{}}{{}}<<>><<>>(())(())[[]][[]] {<>}{[]}<<<>><<>>>((<>))(())[[(<>)]][[]] ><}{{[]}<<<>><<>>>((<>))(())[[(<>)]][[]]

YES YES YES YES NO

0

 

 

2017-06-03 20:26:15

1

128

N

15

74

0

1740

【栈】计算(calc

小明在你的帮助下,破密了Ferrari设的密码门,正要往前走,突然又出现了一个密码门,门上有一个算式,其中只有“(”“)”“0-9”“+”“-”“*”“/”“^”,求出的值就是密码。小明数学学得不好,还需你帮他的忙。(“/”用整数除法)

输入文件calc.in1行,为一个算式。

输出文件calc.out1行,就是密码。

1+(3+2)*(7^2+6*9)/(2)

258

0

100%的数据满足:算式长度<=30 其中所有数据在2<sup>31</sup>-1的范围内。

 

2017-06-03 20:26:26

1

128

N

0

11

0

1741

【栈】车厢调度

有一个火车站,铁路如图所示,每辆火车从A驶入,再从B方向驶出,同时它的车厢可以重新组合。假设从A方向驶来的火车有n节(n<=1000),分别按照顺序编号为123n。假定在进入车站前,每节车厢之间都不是连着的,并且它们可以自行移动到B处的铁轨上。另外假定车站C可以停放任意多节车厢。但是一旦进入车站C,它就不能再回到A方向的铁轨上了,并且一旦当它进入B方向的铁轨,它就不能再回到车站C<br /> <p> 负责车厢调度的工作人员需要知道能否使它以a1,a2,…,an的顺序从B方向驶出,请来判断能否得到指定的车厢顺序。 </p> <p> <img src="/JudgeOnline/upload/image/20170529/20170529085328_56844.png" alt="" /> </p>

输入文件的第一行为一个整数n,其中n<=1000,表示有n节车厢,第二行为n个数字,表示指定的车厢顺序。

如果可以得到指定的车厢顺序,则输出一个字符串”YES”,否则输出”NO”(注意要大写,不包含引号)。

5 5 4 3 2 1

YES

0

 

 

2017-06-03 20:26:37

1

128

N

14

30

0

1742

【栈】中缀表达式值

输入一个中缀表达式(由0-9组成的运算数、加+*/四种运算符、左右小括号组成。注意“—”也可作为负数的标志,表达式以“@”作为结束符),判断表达式是否合法,如果不合法,请输出“NO”;否则请把表达式转换成后缀形式,再求出后缀表达式的值并输出。<br /> 注意:必须用栈操作,不能直接输出表达式的值。<br />

输入文件的第一行为一个以@结束的字符串。

如果表达式不合法,请输出“NO”,要求大写。<br /> 如果表达式合法,请输出计算结果。<br />

12×8―9

8

0

 

 

2017-06-03 20:26:49

1

128

N

1

1

0

1743

【高精度计算】求N!的值

用高精度方法,求N!的精确值(N以一般整数输入)

10

3628800

 

 

0

 

 

2017-06-03 20:35:22

1

128

N

3

4

0

1744

【高精度计算】求A/B高精度值

计算A/B的精确值,设AB是以一般整数输入,计算结果精确到小数后20位(若不足20位,末尾不用补0,若超过20位,则末尾最后一位四舍五入)。

<p> 4 3 </p> <p> 6 5 </p> <p> 30 5 </p> <p>   </p>

<p> 4/3=1.33333333333333333333 </p> <p> 6/5=1.2 </p> <p> 30/5=6 </p> <p>   </p>

 

 

0

 

 

2017-06-05 18:52:46

1

128

N

1

5

0

1745

【高精度计算】求n累加和

<p> 用高精度方法,求s=1+2+3+……+n的精确值(n以一般整数输入) </p> <p> n的取值可以达到1000000 </p>

10

55

 

 

0

 

 

2017-06-05 20:50:33

1

128

N

6

11

0

1746

【高精度计算】阶乘和

已知正整数NN<=1000,S=1!+2!+3!+...N!。其中"!"表示阶乘,N!=1*2*3*……*(N-1)*N,如:3!=1*2*3=6。请编程实现:输入正整数N,输出计算结果S的值。

4

33

 

 

0

 

 

2017-06-07 21:33:49

1

128

N

2

12

0

1747

【高精度计算】高精度求积

<p> 输入两个高精度正整数MNMN均小于100位)。 </p> <p> 求这两个高精度数的积。 </p>

36<br /> 3<br />

108

 

 

0

 

 

2017-06-03 20:35:33

1

128

N

2

4

0

1748

【高精度计算】天使的起誓

【问题描述】<br /> TENSHI非常幸运地被选为掌管智慧之匙的天使。在正式任职之前,她必须和其他新当选的天使一样,<br /> <p> 要宣誓。宣誓仪式是每位天使各自表述自己的使命,她们的发言稿被放在n个呈圆形排列的宝盒中。这些宝盒按顺时针方向被编上号码123……n-1n。一开始天使们站在编号为N的宝盒旁。她们各自手上都有一个数字,代表她们自己的发言稿所在的盒子是从1号盒子开始按顺时针方向的第几个。例如:有7个盒子,那么如果TENSHI手上的数字为9,那么她的发言稿所在盒子就是第2个。现在天使们开始按照自己手上的数字来找发言稿,先找到的就可以先发言。TENSHI一下子就找到了,于是她最先上台宣誓:我将带领大家开启NOI之门……”TENSHI宣誓结束以后,陆续有天使上台宣誓。可是有一位天使找了好久都找不到她的发言稿,原来她手上的数字M非常大,她转了好久都找不到她想找的宝盒。 </p> <p> 【问题求解】<br /> 请帮助这位天使找到她想找的宝盒的编号。 </p> <p>   </p> <p> (高精度,还是少了一道高精度除以高精度的题,请抽空补上!) </p>

从文件yubikili.in的第一、二行分别读入正整数nm,其中nm满足<br /> 2 ≤ n≤ 10<sup>8</sup>2 ≤ m≤ 10<sup>1000</sup><br />

把所求宝盒的编号输出到文件yubikili.out,文件只有一行(包括换行符)。

【样例一】 7 9 【样例二】 11 108

2 9

0

 

 

2017-06-08 12:58:12

1

128

N

1

1

0

1749

【数据排序】车厢重组

在一个旧式的火车站旁边有一座桥,其桥面可以绕河中心的桥墩水平旋转。一个车站的职工发现桥的长度最多能容纳两节车厢,如果将桥旋转180度,则可以把相邻两节车厢的位置交换,用这种方法可以重新排列车厢的顺序。于是他就负责用这座桥将进站的车厢按车厢号从小到大排列。他退休后,火车站决定将这一工作自动化,其中一项重要的工作是编一个程序,输入初始的车厢顺序,计算最少用多少步就能将车厢排序。

输入文件有两行数据,第一行是车厢总数N(不大于10000),第二行是N个不同的数表示初始的车厢顺序。

一个数据,是最少的旋转次数。

4 4 3 2 1

6

0

 

 

2017-06-03 20:04:45

1

128

N

0

0

0

1750

【数据排序】众数

由文件给出N130000间无序数正整数,其中1≤N≤10000,同一个正整数可能会出现多次,出现次数最多的整数称为众数。求出它的众数及它出现的次数。

输入文件第一行是正整数的个数N,第二行开始为N个正整数。

输出文件有若干行,每行两个数,第1个是众数,第2个是众数出现的次数。

12 2 4 2 3 2 5 3 7 2 3 4 3

2 4 3 4

0

 

 

2017-06-03 20:04:59

1

128

N

0

0

0

1751

【数据排序】第k小整数

现有n个正整数,n≤10000,要求出这n个正整数中的第k个最小整数(相同大小的整数只计算一次),k≤1000,正整数均小于30000

第一行为nk,第二行开始为n个正整数的值,整数间用空格隔开。

k个最小整数的值;若无解,则输出“NO RESULT”

10 3 1 3 3 7 2 5 1 2 4 6

3

0

 

 

2017-06-03 20:05:17

1

128

N

1

2

0

1752

【数据排序】军事机密

军方截获的信息由nn<=30000)个数字组成,因为是敌国的高端秘密,所以一时不能破获。最原始的想法就是对这n个数进行从小到大排序,每个数都对应一个序号,然后对第i个是什么数感兴趣,现在要求编程完成。<br />

第一行n,接着是n个截获的数字,接着一行是数字k,接着是k行要输出数的序号。

k行序号对应的数字。

5 121 1 126 123 7 3 2 4 3

7 123 121

0

 

 

2017-06-03 20:06:09

1

128

N

0

1

0

1753

【数据排序】奖学金(Noip2007)

【问题描述】<br /> 某小学最近得到了一笔赞助,打算拿出其中一部分为学习成绩优秀的前5名学生发奖学金。期末,每个学生都有3门课的成绩:语文、数学、英语。先按总分从高到低排序,如果两个同学总分相同,再按语文成绩从高到低排序,如果两个同学总分和语文成绩都相同,那么规定学号小的同学排在前面,这样,每个学生的排序是唯一确定的。<br /> 任务:先根据输入的3门课的成绩计算总分,然后按上述规则排序,最后按排名顺序输出前5名学生的学号和总分。注意,在前5名同学中,每个人的奖学金都不相同,因此,你必须严格按上述规则排序。例如,在某个正确答案中,如果前两行的输出数据(每行输出两个数:学号、总分)是:<br /> 7 279<br /> 5 279<br /> <p> 这两行数据的含义是:总分最高的两个同学的学号依次是7号、5号。这两名同学的总分都是279(总分等于输入的语文、数学、英语三科成绩之和),但学号为7的学生语文成绩更高一些。如果你的前两名的输出数据是: </p> <p> 5 279 </p> 7 279<br /> 则按输出错误处理,不能得分。<br />

输入文件scholar.in包含n+1行:<br /> 1行为一个正整数n,表示该校参加评选的学生人数。<br /> 2n+1行,每行有3个用空格隔开的数字,每个数字都在0100之间。第j行的3个数字依次表示学号为j-1的学生的语文、数学、英语的成绩。每个学生的学号按照输入顺序编号为1~n(恰好是输入数据的行号减1)。 所给的数据都是正确的,不必检验。<br />

输出文件scholar.out共有5行,每行是两个用空格隔开的正整数, 依次表示前5名学生的学号和总分。<br />

样例一: 6 90 67 80 87 66 91 78 89 91 88 99 77 67 89 64 78 89 98 样例二: 8 80 89 89 88 98 78 90 67 80 87 66 91 78 89 91 88 99 77 67 89 64 78 89 98

样例一: 6 265 4 264 3 258 2 244 1 237 样例二: 8 265 2 264 6 264 1 258 5 258

0

50%的数据满足:各学生的总成绩各不相同<br /> 100%的数据满足:6<=n<=300<br />

 

2017-06-03 20:06:22

1

128

N

0

0

0

1754

【数据排序】统计数字(Noip2007)

某次科研调查时得到了n个自然数,每个数均不超过15000000001.5*10<sup>9</sup>)。已知不相同的数不超过10000个,现在需要统计这些自然数各自出现的次数,并按照自然数从小到大的顺序输出统计结果。

输入文件count.in包含n+1行:<br /> 1行是整数n,表示自然数的个数。<br /> 2~n+1行每行一个自然数。<br />

输出文件count.out包含m行(mn个自然数中不相同数的个数),按照自然数从小到大的顺序输出。每行输出两个整数,分别是自然数和该数出现的次数,其间用一个空格隔开。

2 4 2 4 5 100 2 100

2 3 4 2 5 1 100 2

0

40%的数据满足:1<=n<=1000<br /> 80%的数据满足:1<=n<=50000<br /> 100%的数据满足:1<=n<=200000,每个数均不超过1 500 000 0001.5*109<br />

 

2017-06-03 20:06:34

1

128

N

0

0

0

1755

【数据排序】输油管道问题(pipe)

<p> 某石油公司计划建造一条由东向西的主输油管道。该管道要穿过一个有n 口油井的油田。从每口油井都要有一条输油管道沿最短路径(或南或北)与主管道相连。如果给定n口油井的位置,即它们的x 坐标(东西向)和y 坐标(南北向),应如何确定主管道的最优位置,即使各油井到主管道之间的输油管道长度总和最小的位置?证明可在规定时间内确定主管道的最优位置。 </p> <p> <span style="line-height:14.4px;">给定n 口油井的位置,编程计算各油井到主管道之间的输油管道最小长度总和。</span> </p>

1 行是油井数n1≤n≤10000。接下来n 行是油井的位置,每行2个整数xy-10000≤x,y≤10000

1 行中的数是油井到主管道之间的输油管道最小长度总和。

5 1 2 2 2 1 3 3 -2 3 3

6

0

 

 

2017-06-03 20:06:47

1

128

N

0

0

0

1756

【数据排序】士兵站队问题

【问题描述】<br /> 在一个划分成网格的操场上,n个士兵散乱地站在网格点上。网格点由整数坐标(x,y)表示。士兵们可以沿网格边上、下、左、右移动一步,但在同一时刻任一网格点上只能有一名士兵。按照军官的命令,士兵们要整齐地列成一个水平队列,即排列成(x,y),(x+1,y),…,(x+n-1,y)。如何选择x y的值才能使士兵<br /> 们以最少的总移动步数排成一列。<br /> 【编程任务】<br /> 计算使所有士兵排成一行需要的最少移动步数。<br />

1 行是士兵数n1≤n≤10000。接下来n 行是士兵的初始位置,每行2 个整数x y-10000≤xy≤10000

1 行中的数是士兵排成一行需要的最少移动步数。

5 1 2 2 2 1 3 3 -2 3 3

8

0

 

 

2017-06-03 20:07:01

1

128

N

0

0

0

1757

【递推】走楼梯(stairs)

楼梯有N级台阶,上楼可以一步上一阶,也可以一步上二阶。编一递归程序,计算共有多少种不同走法?<br />

输入一个整数N

输出共有多少种不同的走法

3

3

0

 

 

2017-06-03 20:07:36

1

128

N

1

1

0

1758

【递推】兔子繁殖(rabbit)

有一种兔子,出生后一个月就可以长大,然后再过一个月一对长大的兔子就可以生育一对小兔子且以后每个月都能生育一对。现在,我们有一对刚出生的这种兔子,那么,n个月过后,我们会有多少对兔子呢?假设所有的兔子都不会死亡。

输入文件仅一行,包含一个自然数n

输出文件仅一行,包含一个自然数,即n个月后兔子的对数。

5

5

0

 

 

2017-06-03 20:07:48

1

128

N

1

1

0

1759

【递推】平面分割(surface)

同一平面内有nn≤500)条直线,已知其中pp≥2)条直线相交于同一点,则这n条直线最多能将平面分割成多少个不同的区域?

两个整数nn≤500)和p2≤p≤n)。

一个正整数,代表最多分割成的区域数目。

12 5

73

0

 

 

2017-06-03 20:08:02

1

128

N

0

0

0

1760

【递推】蜜蜂路线(bee)

一只蜜蜂在下图所示的数字蜂房上爬动,已知它只能从标号小的蜂房爬到标号大的相邻蜂房,现在问你:蜜蜂从蜂房M开始爬到蜂房NM<N,有多少种爬行路线?<img src="/JudgeOnline/upload/image/20170529/20170529182244_82550.png" alt="" />

输入MN的值。

爬行有多少种路线。

1 14

377

0

 

 

2017-06-03 20:08:12

1

128

N

0

0

0

1761

【递推】极值问题(acme)

已知mn为整数,且满足下列两个条件:<br /> ① mn∈{1,2,k},即1≤mn≤k<br /> ②n<sup>2</sup>m*nm<sup>2</sup><sup>2</sup>1<br /> 你的任务是:编程输入正整数k1≤k≤10<sup>9</sup>),求一组满足上述两个条件的mn,并且使m<sup>2</sup>n<sup>2</sup>的值最大。例如,从键盘输入k=1995,则输出:m=987 n=1597<br />

<span style="line-height:14.4px;">输入正整数k1≤k≤10</span><sup>9</sup><span style="line-height:14.4px;"></span>

<span style="line-height:14.4px;">求一组满足上述两个条件的mn,并且使m</span><sup>2</sup><span style="line-height:14.4px;">n</span><sup>2</sup><span style="line-height:14.4px;">的值最大</span><br />

1995

m=987 n=1597

0

 

 

2017-06-03 20:08:24

1

128

N

0

0

0

1762

【递推】火车站(Noip1998)

火车从始发站(称为第1站)开出,在始发站上车的人数为a,然后到达第2站,在第2站有人上、下车,但上、下车的人数相同,因此在第2站开出时(即在到达第3站之前)车上的人数保持为a人。从第3站起(包括第3站)上、下车的人数有一定的规律:上车的人数都是前两站上车人数之和,而下车人数等于上一站上车人数,一直到终点站的前一站(第n-1站),都满足此规律。现给出的条件是:共有N个车站,始发站上车的人数为a,最后一站下车的人数是m(全部下车)。试问从x站开出时车上的人数是多少?若无解输出“No answer.”(所有数据均在long范围内)<br />

anmx

x站开出时车上的人数

1 6 7 3

2

0

 

 

2017-06-03 20:08:37

1

128

N

0

0

0

1763

【递归】斐波那切数列

斐波那切数列011235813213455……从第三项起,每一项都是紧挨着的前两项的和。写出计算斐波那切数列的任意一个数据项递归程序。

输入所求的项数。

输出数据项的值。

10

34

0

 

 

2017-06-03 20:09:27

1

128

N

3

3

0

1764

【递归】倒序数(num)

用递归算法写程序,输入一个非负整数,输出这个数的倒序数。

输入一个非负整数。

输出倒序结果。

123

321

0

 

 

2017-06-03 20:09:42

1

128

N

1

3

0

1765

【递归】十进制转换成八进制(change)

用递归算法,把任一给定的十进制正整数转换成八进制数输出。

输入一个正整数,表示需要转换的十进制数。

输出一个正整数,表示转换之后的八进制的数。

15

17

0

 

 

2017-06-03 20:09:53

1

128

N

29

44

0

1766

【递归】求N!的值

用递归算法,求N!的精确值(N以一般整数输入)

10

10!=3628800

 

 

0

 

 

2017-06-03 20:10:05

1

128

N

1

7

0

1767

【递归】求最大公约数(gcdmax)

用递归方法求两个数 m  n 的最大公约数。(m>0n>0)

输入二个数,即m  n 的值。

输出最大公约数。

8 6

gcd=2

0

 

 

2017-06-03 20:10:13

1

128

N

2

4

0

1768

【递归】双色Hanoi塔问题(hanoi)

ABC3 个塔座。开始时,在塔座A 上有一叠共n 个圆盘,这些圆盘自下而上,由大到小地叠在一起。各圆盘从小到大编号为12……n,奇数号圆盘着蓝色,偶数号圆盘着红色,如图所示。现要求将塔座A 上的这一叠圆盘移到塔座B 上,并仍按同样顺序叠置。在移动圆盘时应遵守以下移动规则:<br /> 规则(1):每次只能移动1 个圆盘;<br /> 规则(2):任何时刻都不允许将较大的圆盘压在较小的圆盘之上;<br /> 规则(3):任何时刻都不允许将同色圆盘叠在一起;<br /> <p> 规则(4):在满足移动规则(1)-(3)的前提下,可将圆盘移至ABC 中任一塔座上。 </p> <p> <img src="/JudgeOnline/upload/image/20170529/20170529192135_68899.png" alt="" /> </p> <p> 试设计一个算法,用最少的移动次数将塔座A 上的n个圆盘移到塔座B 上,并仍按同样顺序叠置。 </p> <p> 对于给定的正整数n,编程计算最优移动方案。 </p>

1 行是给定的正整数n

每一行由一个正整数k2个字符c1c2组成,表示将第k个圆盘从塔座c1移到塔座c2上。

3

1 A B 2 A C 1 B C 3 A B 1 C A 2 C B 1 A B

0

 

 

2017-06-03 20:10:28

1

128

N

0

0

0

1769

【递归】背包问题

简单的背包问题。设有一个背包,可以放入的重量为s。现有n件物品,重量分别为w1,w2…wn,(1≤i≤n)均为正整数,从n件物品中挑选若干件,使得放入背包的重量之和正好为s。找到一组解即可。

第一行是物品总件数和背包的载重量,第二行为各物品的重量。

各所选物品的序号和重量。

5 10 1 2 3 4 5

number:1 weight:1 number:4 weight:4 number:5 weight:5

0

 

 

2017-06-03 20:10:38

1

128

N

0

0

0

1770

【搜索与回溯】全排列问题

<p> 输出自然数1n所有不重复的排列,即n的全排列,要求所产生的任一数字序列中不允许出现重复的数字。 </p> <p> 注意一下数据输出时,场宽为5,如:printf("5d%",dat[i]) </p>

n(1≤n≤9)

1n组成的所有不重复的数字序列,每行一个序列。

3

1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1

0

 

 

2017-06-07 15:53:53

1

128

N

4

18

0

1771

【搜索与回溯】组合的输出

排列与组合是常用的数学方法,其中组合就是从n个元素中抽出r个元素(不分顺序且r<n),我们可以简单地将n个元素理解为自然数12n,从中任取r个数。<br /> 现要求你用递归的方法输出所有组合。<br /> 例如n5r3,所有组合为:<br /> 1 2 3   1 2 4   1 2 5   1 3 4   1 3 5   1 4 5   2 3 4   2 3 5   2 4 5   3 4 5<br />

一行两个自然数nr(1<n<211<r<n)

所有的组合,每一个组合占一行且其中的元素按由小到大的顺序排列,每个元素占三个字符的位置,所有的组合也按字典顺序。

5 3

1 2 3 1 2 4 1 2 5 1 3 4 1 3 5 1 4 5 2 3 4 2 3 5 2 4 5 3 4 5

0

 

 

2017-06-03 20:27:30

1

128

N

0

0

0

1772

【搜索与回溯】N皇后问题

<p> N*N的棋盘上放置N个皇后(n<=10)而彼此不受攻击(即在棋盘的任一行,任一列和任一对角线上不能放置2个皇后),编程求解所有的摆放方法。 </p> <p> <img src="/JudgeOnline/upload/image/20170529/20170529193433_25694.png" alt="" /> </p>

输入:n

每行输出一种方案,每种方案顺序输出皇后所在的列号,各个数之间有空格隔开。若无方案,则输出no solute!

4

2 4 1 3 3 1 4 2

0

注意最后一个数没空格,否则会格式错误

 

2017-07-18 10:58:54

1

128

N

12

22

0

1773

【搜索与回溯】有重复元素的排列问题

<p> R={ r1, r2 , …, rn}是要进行排列的n个元素。其中元素r<sub>1</sub>, r<sub>2</sub> , …, rn可能相同。试设计一个算法,列出R的所有不同排列。 </p> <p> 给定n 以及待排列的n 个元素。计算出这n 个元素的所有不同排列。 </p>

perm.in输入数据。文件的第1 行是元素个数n1≤n≤500。接下来的1 行是待排列的n个元素。

计算出的n个元素的所有不同排列输出到文件perm.out中。文件最后1行中的数是排列总数。

4 aacc

aacc acac acca caac caca ccaa 6

0

 

 

2017-06-03 20:27:54

1

128

N

0

0

0

1774

【搜索与回溯】子集和问题(subsum)

<p> 子集和问题的一个实例为〈S,t〉。其中,S={ x1 x2 xn}是一个正整数的集合,c是一个正整数。子集和问题判定是否存在S的一个子集S1,使得子集S1和等于c </p> <p> 【编程任务】<br /> 对于给定的正整数的集合S={ x1 x2 xn}和正整数c,编程计算S 的一个子集S1,使得子集S1和等于c </p>

由文件subsum.in提供输入数据。文件第1行有2个正整数ncn表示S的个数,c是子集和的目标值。接下来的1 行中,有n个正整数,表示集合S中的元素。

程序运行结束时,将子集和问题的解输出到文件subsum.out中。当问题无解时,输出“No solution!”

5 10 2 2 6 5 4

2 2 6

0

 

 

2017-06-03 20:28:04

1

128

N

0

0

0

1775

【搜索与回溯】工作分配问题(job)

设有n件工作分配给n个人。将工作i分配给第j个人所需的费用为cij。试设计一个算法,为每一个人都分配一件不同的工作,并使总费用达到最小。<strong>设计一个算法,对于给定的工作费用,计算最佳工作分配方案,使总费用达到最小。</strong>

<span style="line-height:14.4px;">由文件job.in给出输入数据。第一行有1个正整数n (1≤n≤20)。接下来的n行,每行n个数,第i行表示第i个人各项工作费用。</span><br />

将计算出的最小总费用输出到文件job.out

3 4 2 5 2 3 6 3 4 5

9

0

 

 

2017-06-03 20:28:12

1

128

N

0

0

0

1776

【搜索与回溯】装载问题(load)

有一批共n个集装箱要装上艘载重量为c的轮船,其中集装箱i的重量为wi。找出一种最优装载方案,将轮船尽可能装满,即在装载体积不受限制的情况下,将尽可能重的集装箱装上轮船。<br />

由文件load.in给出输入数据。第一行有2个正整数ncn是集装箱数,c是轮船的载重量。接下来的1行中有n个正整数,表示集装箱的重量。

将计算出的最大装载重量输出到文件load.out

5 10 7 2 6 5 4

10

0

 

 

2017-06-03 20:28:25

1

128

N

0

0

0

1777

【搜索与回溯】字符序列(characts)

从三个元素的集合[ABC]中选取元素生成一个N个字符组成的序列,使得没有两个相邻字的子序列(子序列长度=2)相同。例:N = 5ABCBA是合格的,而序列ABCBCABABC是不合格的,因为其中子序列BCAB是相同的。<br /> 对于由键盘输入的N(1<=N<=12),求出满足条件的N个字符的所有序列和其总数。<br />

4

72

 

 

0

 

 

2017-06-03 20:28:38

1

128

N

0

0

0

1778

【搜索与回溯】迷宫问题(migong)

设有一个N*N(2<=N<10)方格的迷宫,入口和出口分别在左上角和右上角。迷宫格子中分别放010表示可通,1表示不能,入口和出口处肯定是0。迷宫走的规则如下所示:即从某点开始,有八个方向可走,前进方格中数字为0时表示可通过,为1时表示不可通过,要另找路径。找出所有从入口(左上角)到出口(右上角)的路径(不能重复),输出路径总数,如果无法到达,则输出0

3<br /> 0 0 0<br /> 0 1 1<br /> 1 0 0<br />

2 //路径总数

 

 

0

 

 

2017-06-03 20:28:47

1

128

N

6

11

0

1779

【搜索与回溯】部落卫队

<p> 原始部落byteland中的居民们为了争夺有限的资源,经常发生冲突。几乎每个居民都有他的仇敌。部落酋长为了组织一支保卫部落的队伍,希望从部落的居民中选出最多的居民入伍,并保证队伍中任何2 个人都不是仇敌。 </p> <p> 给定byteland部落中居民间的仇敌关系,编程计算组成部落卫队的最佳方案。 </p>

1行有2个正整数nm,表示byteland部落中有n个居民,居民间有m个仇敌关系。居民编号为12n。接下来的m行中,每行有2个正整数uv,表示居民u与居民v是仇敌。

1行是部落卫队的总人数;第2行是卫队组成x i1≤i≤nxi =0 表示居民i不在卫队中,xi=1表示居民i在卫队中。

7 10 1 2 1 4 2 4 2 3 2 5 2 6 3 5 3 6 4 5 5 6

3 1 0 1 0 0 0 1

0

 

 

2017-06-03 20:28:56

1

128

N

0

0

0

1780

【搜索与回溯】最佳调度问题

<p> 假设有n个任务由k个可并行工作的机器完成。完成任务i需要的时间为ti。试设计一个算法找出完成这n个任务的最佳调度,使得完成全部任务的时间最早。 </p> <p> 对任意给定的整数nk,以及完成任务i需要的时间为tii=1~n。编程计算完成这n个任务的最佳调度。 </p>

由文件machine.in给出输入数据。第一行有2 个正整数nk。第2 行的n个正整数是完成n个任务需要的时间。

将计算出的完成全部任务的最早时间输出到文件machine.out

7 3 2 14 4 16 6 5 3

17

0

 

 

2017-06-03 20:29:08

1

128

N

0

0

0

1781

【搜索与回溯】图的m着色问题

<p> 给定无向连通图Gm种不同的颜色。用这些颜色为图G的各顶点着色,每个顶点着一种颜色。如果有一种着色法使G中每条边的2个顶点着不同颜色,则称这个图是m可着色的。图的m着色问题是对于给定图Gm种颜色,找出所有不同的着色法。 </p> <p> 对于给定的无向连通图Gm种不同的颜色,编程计算图的所有不同的着色法。 </p>

1行有3个正整数nk m,表示给定的图Gn个顶点和k条边,m种颜色。顶点编号为12n。接下来的k行中,每行有2个正整数u,v,表示图G 的一条边(u,v)<br />

<span style="line-height:14.4px;">将计算出的不同的着色方案数输出。</span>

5 8 4 1 2 1 3 1 4 2 3 2 4 2 5 3 4 4 5

48

0

 

 

2017-06-03 20:29:18

1

128

N

2

2

0

1782

【贪心】排队接水

n个人在一个水龙头前排队接水,假如每个人接水的时间为Ti,请编程找出这n个人排队的一种顺序,使得n个人的平均等待时间最小。

输入文件共两行,第一行为n;第二行分别表示第1个人到第n个人每人的接水时间T1T2Tn,每个数据之间有1个空格。

输出文件有两行,第一行为一种排队顺序,即1n的一种排列;第二行为这种排列方案下的平均等待时间(输出结果精确到小数点后两位)

10 56 12 1 99 1000 234 33 55 99 812

3 2 7 8 1 4 9 6 10 5 532.00

0

n1000以内

 

2017-07-17 21:38:10

1

128

N

0

8

0

1783

【贪心】最大整数(Noip1998连接多位数)

设有n个正整数(n≤20),将它们联接成一排,组成一个最大的多位整数。<br /> 例如:n=3时,3个整数13312343联接成的最大整数为:34331213<br /> 又如:n=4时,4个整数7134246联接成的最大整数为:7424613<br />

n<br /> n个数<br />

联接成的多位数

3 13 312 343

34331213

0

 

 

2017-06-03 20:29:54

1

128

N

0

0

0

1784

【贪心】纪念品分组(NOIP2007)

元旦快到了,校学生会让乐乐负责新年晚会的纪念品发放工作。为使得参加晚会的同学所获得的纪念品价值相对均衡,他要把购来的纪念品根据价格进行分组,但每组最多只能包括两件纪念品,并且每组纪念品的价格之和不能超过一个给定的整数。为了保证在尽量短的时间内发完所有纪念品,乐乐希望分组的数目最少。<br /> 你的任务是写一个程序,找出所有分组方案中分组数最少的一种,输出最少的分组数目。<br />

输入文件group.in包含n+2行:<br /> 1行包括一个整数w,为每组纪念品价格之和的上限。<br /> 2行为一个整数n,表示购来的纪念品的总件数。<br /> 3~n+2行每行包含一个正整数pi (5 <= pi <= w),表示所对应纪念品的价格。<br />

输出文件group.out仅一行,包含一个整数,即最少的分组数目。

100 9 90 20 20 30 50 60 70 80 90

6

0

50%的数据满足:1 <= n <= 15<br /> 100%的数据满足:1 <= n <= 30000, 80 <= w <= 200<br />

 

2017-06-03 20:30:04

1

128

N

14

27

0

1785

【贪心】合并果子(Noip2004)

在一个果园里,多多已经将所有的果子打了下来,而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。<br /> 每一次合并,多多可以把两堆果子合并到一起,消耗的体力等于两堆果子的重量之和。可以看出,所有的果子经过n-1次合并之后,就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。<br /> 因为还要花大力气把这些果子搬回家,所以多多在合并果子时要尽可能地节省体力。假定每个果子重量都为1,并且已知果子的种类数和每种果子的数目,你的任务是设计出合并的次序方案,使多多耗费的体力最少,并输出这个最小的体力耗费值。<br /> 例如有3种果子,数目依次为129。可以先将 12堆合并,新堆数目为3,耗费体力为3。接着,将新堆与原先的第三堆合并,又得到新的堆,数目为12,耗费体力为 12。所以多多总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。<br />

输入文件fruit.in包括两行,第一行是一个整数n1 <= n <= 10000),表示果子的种类数。第二行包含n个整数,用空格分隔,第i个整数ai1 <= ai <= 20000)是第i种果子的数目。

输出文件fruit.out包括一行,这一行只包含一个整数,也就是最小的体力耗费值。输入数据保证这个值小于2<sup>31</sup>

3 1 2 9

15

0

对于30%的数据,保证有n <= 1000<br /> 对于50%的数据,保证有n <= 5000<br /> 对于全部的数据,保证有n <= 10000<br />

 

2017-06-03 20:30:13

1

128

N

20

40

0

1786

【贪心】美元汇率(dollars

在以后的若干天里戴维将学习美元与德国马克的汇率。编写程序帮助戴维何时应买或卖马克或美元,使他从100美元开始,最后能获得最高可能的价值。

输入文件的第一行是一个自然数N1≤N≤100,表示戴维学习汇率的天数。<br /> 接下来的N行中每行是一个自然数A1≤A≤1000。第i+1行的A表示预先知道的第i+1天的平均汇率,在这一天中,戴维既能用100美元买A马克也能用A马克购买100美元。<br />

输出文件的第一行也是唯一的一行应输出要求的钱数(单位为美元,保留两位小数)<br /> 注意:考虑到实数算术运算中进位的误差,结果在正确结果0.05美元范围内的被认为是正确的,戴维必须在最后一天结束之前将他的钱都换成美元。<br />

5 400 300 500 300 250

266.66 样例解释 (无需输出) Day 1 ... changing 100.0000 美元= 400.0000 马克 Day 2 ... changing 400.0000 马克= 133.3333 美元 Day 3 ... changing 133.3333 美元= 666.6666 马克 Day 5 ... changing 666.6666 马克= 266.6666 美元

0

 

 

2017-06-03 20:30:23

1

128

N

0

0

0

1787

【贪心】零件分组(stick)

某工厂生产一批棍状零件,每个零件都有一定的长度(Li)和重量(Wi)。现在为了加工需要,要将它们分成若干组,使每一组的零件都能排成一个长度和重量都不下降(若i<j,则Li<=LjWi<=Wj)的序列。请问至少要分成几组?

第一行为一个整数NN<=1000),表示零件的个数。第二行有N对正整数,每对正整数表示这些零件的长度和重量,长度和重量均不超过10000

仅一行,即最少分成的组数。

5 8 4 3 8 2 3 9 7 3 5

2

0

 

 

2017-06-03 20:30:34

1

128

N

0

0

0

1788

【贪心】运输(trans)

现在已知N件商品。和搬运它们其中每一件的费用。现在搬家公司的老板Mr.B决定让我们每次任意选取2件商品。然后这2件商品只算一件商品的费用。但是这个商品的搬运费用是将选出的2个商品的费用之和除以K的运算结果。如此反复。直到只收一件商品的钱。这个就是商店要付的费用。想尽可能的少付钱,以便将更多的钱卷给希望工程。所以请你帮他计算一下最少只用付多少钱。

n,k<br /> w1,w2,…,wn(每一件商品的搬运费用)<br />

输出一个数字,表示最少付多少钱。

5 2 1 2 3 4 5

1

0

【数据规模】<br /> n<=10000<br /> k<=10000<br />

 

2017-06-03 20:30:44

1

128

N

0

0

0

1789

【贪心】最佳游览线路(Noi1994)

某旅游区的街道成网格状。其中东西向的街道都是旅游街,南北向的街道都是林荫道。由于游客众多,旅游街被规定为单行道,游客在旅游街上只能从西向东走,在<span style="line-height:14.4px;">林荫道</span>上则既可从南向北走,也可以从北向南走。<br /> 阿龙想到这个旅游区游玩。他的好友阿福给了他一些建议,用分值表示所有旅游街相邻两个路口之间的街道值得游览的程度,分值时从-100100的整数,所有<span style="line-height:14.4px;">林荫道</span>不打分。所有分值不可能全是负分。<br /> <p> 例如图是被打过分的某旅游区的街道图: </p> <p> <img src="/JudgeOnline/upload/image/20170529/20170529200337_90683.bmp" alt="" /> </p> <p> 阿龙可以从任一个路口开始游览,在任一个路口结束游览。请你写一个程序,帮助阿龙找一条最佳的游览线路,使得这条线路的所有分值总和最大。 </p>

第一行是两个整数MN,之间用一个空格符隔开,M表示有多少条旅游街(1≦M≦100),N表示有多少条<span style="line-height:14.4px;">林荫道</span>1≦M≦20001)。接下来的M行依次给出了由北向南每条旅游街的分值信息。每行有N个整数,依次表示了自西向东旅游街每一小段的分值。同一行相邻两个数之间用一个空格隔开。

只有一行,是一个整数,表示你的程序找到的最佳游览线路的总分值。

3 5 -50 -47 36 -30 -23 17 -19 -34 -13 -8 -42 -3 -43 34 -45

84

0

 

 

2017-06-10 12:44:08

1

128

N

11

56

0

1790

【贪心】营养膳食(diet)

阿月正在女朋友宁宁的监督下完成自己的增肥计划。<br /> 为了增肥,阿月希望吃到更多的脂肪。然而也不能只吃高脂肪食品,那样的话就会导致缺少其他营养。阿月通过研究发现:真正的营养膳食规定某类食品不宜一次性吃超过若干份。比如就一顿饭来说,肉类不宜吃超过1份,鱼类不宜吃超过1份,蛋类不宜吃超过1份,蔬菜类不宜吃超过2份。阿月想要在营养膳食的情况下吃到更多的脂肪,当然阿月的食量也是有限的。<br />

<p> 第一行包含三个正整数nn≤200,mm≤100)和kk≤100)。 </p> <p> 表示阿月每顿饭最多可以吃m份食品,同时有n种食品供阿月选择,而这n种食品分为k类。 </p> <p> 第二行包含k个不超过10的正整数,表示可以吃1k类食品的最大份数。 </p> <p> 接下来n行每行包括2个正整数,分别表示该食品的脂肪指数ai和所属的类别bi,其中ai≤100bi≤k </p>

一个数字即阿月可以吃到的最大脂肪指数和。

6 6 3 3 3 2 15 1 15 2 10 2 15 2 10 2 5 3

60

0

 

 

2017-07-19 18:54:05

1

128

N

15

37

0

1791

【分治】方程f(x)的根

求方程f(x)=2<sup>x</sup>+3<sup>x</sup>-4<sup>x</sup>=0[12]内的根。<br /> 提示:2<sup>x</sup>可以表示成exp(x*log(2))的形式(需包含cmath库)。<br />

输入[12]的区间值。

输出方程f(x)=0的根,x的值精确小数点10位。

1 2

1.5071105957

0

 

 

2017-06-03 20:32:38

1

128

N

0

0

0

1792

【分治】二分查找(binary)

给出有n个元素的由小到大的序列,请你编程找出某元素第一次出现的位置。(n<=10^6)

第一行:一个整数,表示由小到大序列元素个数;下面n行,每行一个整数;最后一行一个整数x,表示待查找的元素;

如果x在序列中,则输出x第一次出现的位置,否则输出-1

5 3 5 6 6 7 6

3

0

 

 

2017-06-03 20:32:47

1

128

N

0

0

0

1793

【分治】求逆序对(deseq)

给定一个序列a1,a2,…,an,如果存在i<j并且ai>aj,那么我们称之为逆序对,求逆序对的数目。

第一行为n,表示序列长度,接下来的n行,第i+1行表示序列中的第i个数。

所有逆序对总数。

4 3 2 3 2

3

0

【数据范围】<br /> N<=105Ai<=105<br />

 

2017-06-03 20:32:56

1

128

N

0

0

0

1794

【分治】麦森数(mason)

形如2<sup>P</sup>-1的素数称为麦森数,这时P一定也是个素数。但反过来不一定,即如果P是个素数,2<sup>P</sup>-1不一定也是素数。到1998年底,人们已找到了37个麦森数。最大的一个是P=3021377,它有909526位。麦森数有许多重要应用,它与完全数密切相关。<br /> 任务:从文件中输入P1000<P<3100000),计算2<sup>P</sup>-1的位数和最后500位数字(用十进制高精度数表示)。<br />

文件中只包含一个整数P1000<P<3100000)。

第一行:十进制高精度数2<sup>P</sup>-1的位数;<br /> 2-11行:十进制高精度数2<sup>P</sup>-1的最后500位数字(每行输出50位,共输出10行,不足500位时高位补0);<br /> 不必验证2<sup>P</sup>-1P是否为素数。<br />

1279

386 00000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000 00000000000000104079321946643990819252403273640855 38615262247266704805319112350403608059673360298012 23944173232418484242161395428100779138356624832346 49081399066056773207629241295093892203457731833496 61583550472959420547689811211693677147548478866962 50138443826029173234888531116082853841658502825560 46662248318909188018470682222031405210266984354887 32958028878050869736186900714720710555703168729087

0

 

 

2017-06-03 20:33:07

1

128

N

1

1

0

1795

【广度优先搜索】面积(area)

编程计算由“*”号围成的下列图形的面积。面积计算方法是统计*号所围成的闭合曲线中水平线和垂直线交点的数目。如下图所示,在10*10的二维数组中,有“*”围住了15个点,因此面积为15<br /> 0 0 0 0 0 0 0 0 0 0<br /> 0 0 0 0 * * * 0 0 0<br /> 0 0 0 0 * 0 0 * 0 0<br /> 0 0 0 0 0 * 0 0 * 0<br /> 0 0 * 0 0 0 * 0 * 0<br /> 0 * 0 * 0 * 0 0 * 0<br /> 0 * 0 0 * * 0 * * 0<br /> 0 0 * 0 0 0 0 * 0 0<br /> 0 0 0 * * * * * 0 0<br /> 0 0 0 0 0 0 0 0 0 0<br />

0 0 0 0 0 0 0 0 0 0<br /> 0 0 0 0 1 1 1 0 0 0<br /> 0 0 0 0 1 0 0 1 0 0<br /> 0 0 0 0 0 1 0 0 1 0<br /> 0 0 1 0 0 0 1 0 1 0<br /> 0 1 0 1 0 1 0 0 1 0<br /> 0 1 0 0 1 1 0 1 1 0<br /> 0 0 1 0 0 0 0 1 0 0<br /> 0 0 0 1 1 1 1 1 0 0<br /> 0 0 0 0 0 0 0 0 0 0<br />

15

 

 

0

 

 

2017-06-03 20:33:44

1

128

N

0

0

0

1796

【广度优先搜索】营救(save)

泰坦尼克号遇险了!他发出了求救信号。距离最近的哥伦比亚号收到了讯息,时间就是生命,必须尽快赶到那里。<br /> 通过侦测,哥伦比亚号获取了一张海洋图。这张图将海洋部分分化成n*n个比较小的单位,其中用1标明的是陆地,用0标明是海洋。船只能从一个格子,移到相邻的四个格子。<br /> 为了尽快赶到出事地点,哥伦比亚号最少需要走多远的距离。<br />

第一行为n,下面是一个n*n01矩阵,表示海洋地图<br /> 最后一行为四个小于n的整数,分别表示哥伦比亚号和泰坦尼克号的位置。<br />

哥伦比亚号到泰坦尼克号的最短距离,答案精确到整数。

3 001 101 100 1 1 3 3

4

0

【数据范围】<br /> N<=1000<br />

 

2018-04-10 10:57:42

1

128

N

5

18

0

1797

【广度优先搜索】最少转弯问题(turn)

<p> 给出一张地图,这张地图被分为n×mn,m<=100)个方块,任何一个方块不是平地就是高山。平地可以通过,高山则不能。现在你处在地图的(x1,y1)这块平地,问:你至少需要拐几个弯才能到达目的地(x2,y2)?你只能沿着水平和垂直方向的平地上行进,拐弯次数就等于行进方向的改变(从水平到垂直或从垂直到水平)的次数。例如:如图8-6,最少的拐弯次数为5 </p> <p> <img src="/JudgeOnline/upload/image/20170529/20170529203119_83629.png" alt="" /> </p>

1行:n m<br /> 2n+1行:整个地图地形描述(0:空地;1:高山),<br /> 如(图1)第2行地形描述为:1 0 0 0 0 1 0<br /> 3行地形描述为:0 0 1 0 1 0 0<br /> ……<br /> n+2行:x1 y1 x2 y2 (分别为起点、终点坐标)<br />

s (即最少的拐弯次数)

5 7 1 0 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0 0 1 0 1 0 1 1 0 0 0 0 0 0 0 0 1 1 0 1 3 1 7

5

0

 

 

2017-06-03 20:34:02

1

128

N

1

1

0

1798

【广度优先搜索】麻将游戏(mahjong)

在一种"麻将"游戏中,游戏是在一个有w*h格子的矩形平板上进行的。每个格子可以放置一个麻将牌,也可以不放(如图所示)。玩家的目标是将平板上的所有可通过一条路径相连的两张相同的麻将牌,从平板上移去。最后如果能将所有牌移出平板,则算过关。<br /> 这个游戏中的一个关键问题是:两张牌之间是否可以被一条路径所连接,该路径满足以下两个特性:<br /> 1. 它由若干条线段组成,每条线段要么是水平方向,要么是垂直方向。<br /> 2. 这条路径不能横穿任何一个麻将牌 (但允许路径暂时离开平板)<br /> <p> 这是一个例子: </p> <p> <img src="/JudgeOnline/upload/image/20170529/20170529203327_16051.png" alt="" /> </p> <p> 在(13)的牌和在(4, 4)的牌可以被连接。(2, 3)(3, 4)不能被连接。<br /> 你的任务是编一个程序,检测两张牌是否能被一条符合以上规定的路径所连接。<br /> 输入格式:<br /> 输入文件的第一行有两个整数wh 1<=wh<=75),表示平板的宽和高。接下来h行描述平板信息,每行包含w个字符,如果某格子有一张牌,则这个格子上有个'X',否则是一个空格。平板上最左上角格子的坐标为(11),最右下角格子的坐标为(w,h)。接下来的若干行,每行有四个数x1 y1 x2 y2 ,且满足1<=x1,x2<=w1<=y1,y2<=h,表示两张牌的坐标(这两张牌的坐标总是不同的)。如果出现连续四个0,则表示输入结束。<br /> 输出格式:<br /> 输出文件中,对于每一对牌输出占一行,为连接这一对牌的路径最少包含的线段数。如果不存在路径则输出0 </p> <p> <br /> </p>

5 4<br /> XXXXX<br /> X X<br /> XXX X<br /> XXX<br /> 2 3 5 3<br /> 1 3 4 4<br /> 2 3 3 4<br /> 0 0 0 0<br />

4<br /> 3<br /> 0<br />

 

 

0

 

 

2017-06-03 20:34:17

1

128

N

1

1

0

1799

哈夫曼树

<span style="font-size:14px;font-family:'MicroSoft Yahei', Helvetica, Arial, Georgia, Simsun;color:#333333;line-height:25px;background-color:#ffffff;">哈夫曼树,第一行输入一个数n,表示叶结点的个数。需要用这些叶结点生成哈夫曼树,根据哈夫曼树的概念,这些结点有权值,即weight,题目需要输出树的带权路径长度WPLWPL为所有叶子结点的带权路径长度之和。</span>

<span style="font-size:14px;font-family:'MicroSoft Yahei', Helvetica, Arial, Georgia, Simsun;color:#333333;line-height:25px;background-color:#ffffff;">第一行输入一个数n,接着输入n个叶节点的权值(叶节点权值不超过1002<=n<=1000)。</span>

<span style="font-size:14px;font-family:'MicroSoft Yahei', Helvetica, Arial, Georgia, Simsun;color:#333333;line-height:25px;background-color:#ffffff;">输出哈夫曼树的WPL</span>

5 1 2 2 5 9

37

0

 

 

2017-06-02 20:13:19

1

128

N

16

28

0

1800

【动态规划】砝码称重(weight)

设有 1g2g3g5g10g20g 的砝码各若干枚(其总重≤1000g)。 

a1 a2 a3 a4 a5 a6(表示 1g 砝码有 a1 个,2g 砝码有 a2 个,....20g 砝码有 a6

Total=N (N 表示用这些砝码能称出的不同重量的个数,但不包括一个砝码也不用的情况)  

1 1 0 0 0 0

Total=3 //表示可以称出 1g2g3g 三种不同的重量

0

 

 

2017-06-03 20:34:50

1

128

N

0

0

0

1801

【动态规划】装箱问题(boxes)

有一个箱子容量为 v(正整数,0≤v≤20000),同时有 n 个物品(0<n≤30),每个物品<br /> 有一个体积(正整数)。<br /> 要求从 n 个物品中,任取若干个装入箱内,使箱子的剩余空间为最小。 <br />

<p> 箱子的容量 v </p> <p> 物品数 n </p> <p> 接下来 n 行,分别表示这 n 个物品的体积 </p>

箱子剩余空间 

24 6 8 3 12 7 9 7

0

0

 

 

2017-06-03 20:38:11

1

128

N

1

1

0

1802

【动态规划】采药(medic)

辰辰是个天资聪颖的孩子,他的梦想是成为世界上最伟大的医师。为此,他想拜附近 最有威望的医师为师。医师为了判断他的资质,给他出了一个难题。医师把他带到一个到处 都是草药的山洞里对他说:孩子,这个山洞里有一些不同的草药,采每一株都需要一些时 间,每一株也有它自身的价值。我会给你一段时间,在这段时间里,你可以采到一些草药。 如果你是一个聪明的孩子,你应该可以让采到的草药的总价值最大。如果你是辰辰,你能完成这个任务吗? 

输入文件 medic.in 的第一行有两个整数 T1 <= T <= 1000)和 M1 <= M <= 100), 用一个空格隔开,T 代表总共能够用来采药的时间,M 代表山洞里的草药的数目。接下来的 M 行每行包括两个在 1  100 之间(包括 1  100)的整数,分别表示采摘某株草药的时间 和这株草药的价值。 

输出文件 medic.out 包括一行,这一行只包含一个整数,表示在规定的时间内,可以 采到的草药的最大总价值。 

70 3 71 100 69 1 1 2

3

0

对于 30%的数据,M <= 10; 对于 100%的数据,M <= 100 

 

2017-06-03 20:38:17

1

128

N

1

7

0

1803

【动态规划】开心的金明(happy)

金明今天很开心,家里购置的新房就要领钥匙了,新房里有一间他自己专用的很宽敞的 房间。更让他高兴的是,妈妈昨天对他说:你的房间需要购买哪些物品,怎么布置,你说 了算,只要不超过 N 元钱就行。今天一早金明就开始做预算,但是他想买的东西太多了, 肯定会超过妈妈限定的 N 元。于是,他把每件物品规定了一个重要度,分为 5 等:用整数 1~5 表示,第 5 等最重要。他还从因特网上查到了每件物品的价格(都是整数元)。他希望 在不超过 N 元(可以等于 N 元)的前提下,使每件物品的价格与重要度的乘积的总和最大。 设第j件物品的价格为v[j],重要度为w[j],共选中了k件物品,编号依次为j1j2…… jk,则所求的总和为: v[j1]*w[j1]+v[j2]*w[j2]+ …+v[jk]*w[jk]。(其中*为乘号) 请你帮助金明设计一个满足要求的购物单。

<p> 输入文件 happy.in 的第 1 行,为两个正整数,用一个空格隔开: </p> <p>  N m </p> <p> (其中 N<30000)表示总钱数,m<25)为希望购买物品的个数。) </p> <p> 从第 2 行到第 m+1 行,第 j 行给出了编号为 j-1 的物品的基本数据,每行有 2 个非负整数。 </p> <p>  v p </p> <p> (其中 v 表示该物品的价格(v<=10000)p 表示该物品的重要度(1~5)  </p>

输出文件 happy.out 只有一个正整数,为不超过总钱数的物品的价格与重要度乘积的 总和的最大值(<100000000)。 

1000 5 800 2 400 5 300 5 400 3 200 2

3900

0

 

 

2017-06-03 20:38:23

1

128

N

2

2

0

1804

【动态规划】竞赛总分(inflate)

学生在我们USACO的竞赛中的得分越多我们越高兴。我们试着设计我们的竞赛以便人们 能尽可能多得分。现在要进行一次竞赛,总时间T固定,有若干类型可选择的题目,每种类型题目可选入 的数量不限,每种类型题目有一个 si(解答此题所得的分数)和 ti(解答此题所需的时间), 现要选择若干题目,使解这些题的总时间在 T 以内的前提下,所得的总分最大。

<p> 输入包括竞赛的时间 M(1 <= M <= 10000)和题目类型数目 N(1 <= N <= 10000) </p> <p> 后面的每一行将包括两个整数来描述一种"题型": 第一个整数说明解决这种题目能得的分数(1 <= points <= 10000),第二整数说明解决 这种题目所需的时间(1 <= minutes <= 10000)  </p> <p> <br /> </p> <p>  1 : 两个整数:竞赛的时间 M 和题目类型数目 N </p> <p>  2-N+1 : 两个整数:每种类型题目的分数和耗时。 </p> <p> <br /> </p>

<p> 单独的一行,在给定固定时间里得到的最大的分数。  </p>

300 4 100 60 250 120 120 100 35 20

605 //从第2种类型中选两题和第4种类型中选三题

0

 

 

2017-06-03 20:38:29

1

128

N

0

0

0

1805

【动态规划】最小乘车费用(busses)

<p> 某条街上每隔一公里就有一汽车站,乘车费用如下表: </p> <p> <table style="width:100%;" cellpadding="2" cellspacing="0" border="1" bordercolor="#000000"> <tbody> <tr> <td> 公里数 </td> <td> 1 </td> <td> 2 </td> <td> 3 </td> <td> 4 </td> <td> 5 </td> <td> 6 </td> <td> 7 </td> <td> 8 </td> <td> 9 </td> <td> 10 </td> </tr> <tr> <td> 费用 </td> <td> 12 </td> <td> 21 </td> <td> 31 </td> <td> 40 </td> <td> 49 </td> <td> 58 </td> <td> 69 </td> <td> 79 </td> <td> 90 </td> <td> 101 </td> </tr> </tbody> </table> <span id="__kindeditor_bookmark_start_12__">而一辆汽车从不行驶超过 10 公里。某人想行驶 n 公里,假设他可以任意次换车,请你 帮他找到一种乘车方案使费用最小(10 公里的费用比 1 公里小的情况是允许的)。 </span> </p>

输入文件共两行,第一行为 10 个不超过 100 的整数,依次表示行驶 110 公里的费用, 相邻两数间用空格隔开;第二行为某人想要行驶的公里数。 

输出文件仅一行包含一个整数,表示该测试点的最小费用。 

12 21 31 40 49 58 69 79 90 101 15

147

0

 

 

2017-06-03 20:40:34

1

128

N

0

0

0

1806

【动态规划】质数和分解(prime)

<p> 任何大于1的自然数N,都可以写成若干个大于等于2且小于等于N的质数之和表达式(包 括只有一个数构成的和表达式的情况),并且可能有不止一种质数和的形式。例如9的质数和 表达式就有四种本质不同的形式:9 = 2+5+2 = 2+3+2+2 = 3+3+3 = 2+7 </p> <p> 这里所谓两个本质相同的表达式是指可以通过交换其中一个表达式中参加和运算的各个数的位置而直接得到另一个表达式。 </p> <p> 试编程求解自然数N可以写成多少种本质不同的质数和表达式。  </p>

文件中的每一行存放一个自然数N,2≤N≤200 

依次输出每一个自然数N的本质不同的质数和表达式的数目。 

2 200

1 9845164

0

 

 

2017-06-03 20:40:42

1

128

N

0

0

0

1807

【动态规划】逃亡的准备(hallows)

在《Harry Potter and the Deathly Hallows》中,Harry Potter他们一起逃亡,现在有许多的东西要放到赫敏的包里面,但是包的大小有限,所以我们只能够在里面放入非常重要的物品,现在给出该种物品的数量、体积、价值的数值,希望你能够算出能使背包的价值最大的组合方式,并且输出这个数值,赫敏会非常地感谢你。<br />

第一行有2个整数,物品种数n和背包装载体积v<br /> 2行到i+1行每行3个整数,为第i种物品的数量m、体积w、价值s<br />

包含一个整数,即为能拿到的最大的物品价值总和。

2 10 3 4 3 2 2 5

13

0

<p> 【注释】<br /> 选第一种一个,第二种两个。结果为3*1+5*2=13<br /> 【数据规模】<br /> 对于30%的数据<br /> 1<=v<=5001<=n<=20001<=m<=101<=w<=201<=s<=100<br /> 对于100%的数据<br /> 1<=v<=5001<=n<=20001<=m<=50001<=w<=201<=s<=100 </p> <p> <br /> </p>

 

2017-06-03 20:40:48

1

128

N

0

0

0

1808

【动态规划】暗黑游戏(pgrune)

暗黑游戏中,装备直接决定玩家人物的能力。可以使用PgRune购买需要的物品。暗黑市场中的装备,每件有不同的价格(PgRune)、能力值、最大可购买件数。Kid作为暗黑战网的一个玩家,当然希望使用尽可能少的PgRune购买更优的装备,以获得最高的能力值。请你帮忙计算出现有支付能力下的最大可以获得的能力值。

第一行,三个整数N,P,R,分别代表市场中物品种类,Pg的支付能力和Rune的支付能力。<br /> 2..N+1行,每行四个整数,前两个整数分别为购买此物品需要花费的PgRune,第三个整数若为0,则说明此物品可以购买无数件,若为其他数字,则为此物品可购买的最多件数(S),第四个整数为该装备的能力值。<br />

仅一行,一个整数,最大可获得的能力值。

3 10 10 5 3 0 110 4 3 4 120 2 3 1 130

370

0

【样例解释】<br /> 选第二种装备2件和第三种装备1件。<br /> 【数据规模】<br /> 对于30%的数据, 0<N<=50, 0<P<=30, 0<R<=30, 0<=S<=8<br /> 对于70%的数据, 0<N<=80, 0<P<=65, 0<R<=65, 0<=S<=16;<br /> 对于100%的数据, 0<N<=150, 0<P<=100, 0<R<=100, 0<=S<=32;<br />

 

2017-06-03 20:40:54

1

128

N

0

0

0

1809

【动态规划】打包(pack)

你现在拿到了许多的礼物,你要把这些礼物放进袋子里。你只有一个最多装下V 体积物品的袋子,你不能全部放进去。你也拿不动那么重的东西。你估计你能拿的最大重量为G<br /> 现在你了解了每一个物品的完美值、重量和体积,你当然想让袋子中装的物品的完美值总和最大,你又得计划一下了。<br />

第一行:V  G 表示最大重量和体积。<br /> 第二行:N 表示拿到 N 件礼物。<br /> 第三到N+2行:每行3个数 Ti Vi Gi 表示各礼物的完美值、重量和体积<br />

输出共一个数,表示可能获得的最大完美值。

6 5 4 10 2 2 20 3 2 40 4 3 30 3 3

50

0

【数据规模】<br /> 对于20%的数据 NVGTiViGi≤10<br /> 对于50%的数据 NVGTiViGi≤100<br /> 对于80%的数据 NVGTiViGi≤300<br /> 80%100%的数据是NVGTiViGi≤380 的离散随机数据。<br />

 

2017-06-03 20:41:00

1

128

N

0

0

0

1810

【动态规划】暗黑破坏神(diablo)

游戏的主人公有n个魔法,每个魔法分为若干个等级,第i个魔法有p[i]个等级(不包括0),每个魔法的每个等级都有一个效果值,一个j级的i种魔法的效果值为w[i,j],魔法升一级需要一本相应的魔法书,购买魔法书需要金币,第i个魔法的魔法书价格为c[i],而小x只有m个金币。<br /> 你的任务就是帮助小x决定如何购买魔法书才能使所有魔法的效果值之和最大,开始时所有魔法为0级 效果值为0<br />

第一行,用空格隔开的两个整数nm<br /> 以下n行,描述n个魔法,第i+1行描述第i个魔法。 格式如下<br /> c[i] p[i] w[i,1] w[i,2] ... w[i,p[i]]<br />

第一行输出一个整数,即最大效果值。<br /> 以后n行输出你的方案:<br /> i+1行有一个整数v[i] 表示你决定把第i个魔法学到v[i]<br /> 如果有多解,输出花费金币最少的一组<br /> 如果还多解,输出任意一组<br />

3 10 1 3 1 2 2 2 3 2 4 6 3 3 2 1 10

11 1 0 3

0

【数据规模】<br /> 0<n<=1000<m<=5000<p[i]<=500<c[i]<=10<br /> 保证输入数据和最终结果在long范围内<br />

 

2017-06-03 21:37:07

1

128

N

0

0

0

1811

【动态规划】科技庄园(manor)

Life种了一块田,里面种了有一些桃树。<br /> LifePFT说:我给你一定的时间去摘桃,你必须在规定的时间之内回到我面前,否则你摘的桃都要归我吃!”<br /> PFT思考了一会,最终答应了!<br /> 由于PFT的数学不好,他并不知道怎样才能在规定的时间获得最大的价值,<br /> 由于PFT不是机器人,所以他的体力并不是无限的,他不想摘很多的桃以至体力为0,而白白把桃给Life。同时PFT每次只能摘一棵桃树,,每棵桃树都可以摘K次(对于同一棵桃每次摘的桃数相同)。每次摘完后都要返回出发点(PFT一次拿不了很多)即Life的所在地(00{试验田左上角的桃坐标是(11}<br /> PFT每秒只能移动一个单位,每移动一个单位耗费体力1(摘取不花费时间和体力,但只限上下左右移动)<br />

第一行,四个数为NMTIA 分别表示试验田的长和宽,LifePFT的时间和PFT的体力。<br /> 下面一个NM列的矩阵桃田。表示每次每棵桃树上能摘的桃数。<br /> 接下来NM列的矩阵,表示每棵桃最多可以采摘的次数K<br />

一个数,PFT可以获得的最大的桃个数。

4 4 13 20 10 0 0 0 0 0 10 0 0 0 10 0 0 0 0 0 1 0 0 0 0 0 2 0 0 0 4 0 0 0 0 0

10

0

【样例解释】<br /> 可以摘到1次(11)和1次(23),体力和时间不满足再摘桃了。<br /> 【数据范围】<br /> 对于M N TI A10<=30%<=5010<=100%<=100<br /> 对于K10<=100%<=100 保证结果在long范围内<br />

 

2017-06-03 21:37:30

1

128

N

0

0

0

1812

【动态规划】金明的预算方案(budget)

<p> 金明今天很开心,家里购置的新房就要领钥匙了,新房里有一间金明自己专用的很宽敞的房间。更让他高兴的是,妈妈昨天对他说:你的房间需要购买哪些物品,怎么布置,你说了算,只要不超过N元钱就行。今天一早,金明就开始做预算了,他把想买的物品分为两类:主件与附件,附件是从属于某个主件的,下表就是一些主件与附件的例子: </p> <p> <table style="width:100%;" cellpadding="2" cellspacing="0" border="1" bordercolor="#000000"> <tbody> <tr> <td> 主件 </td> <td> 附件 </td> </tr> <tr> <td> 电脑 </td> <td> 打印机,扫描仪 </td> </tr> <tr> <td> 书柜 </td> <td> 图书 </td> </tr> <tr> <td> 书桌 </td> <td> 台灯,文具 </td> </tr> <tr> <td> 工作椅 </td> <td>  </td> </tr> </tbody> </table> <br /> 如果要买归类为附件的物品,必须先买该附件所属的主件。每个主件可以有0个、1个或2个附件。附件不再有从属于自己的附件。金明想买的东西很多,肯定会超过妈妈限定的N元。于是,他把每件物品规定了一个重要度,分为5等:用整数1~5表示,第5等最重要。他还从因特网上查到了每件物品的价格(都是10元的整数倍)。他希望在不超过N元(可以等于N元)的前提下,使每件物品的价格与重要度的乘积的总和最大。<br /> 设第j件物品的价格为v[j],重要度为w[j],共选中了k件物品,编号依次为j1j2……jk,则所求的总和为:<br /> v[j1]*w[j1]+v[j2]*w[j2]+ …+v[jk]*w[jk]。(其中*为乘号)<br /> 请你帮助金明设计一个满足要求的购物单。 </p>

输入文件budget.in 的第1行,为两个正整数,用一个空格隔开:<br /> N m (其中N<32000)表示总钱数,m<60)为希望购买物品的个数。)<br /> 从第2行到第m+1行,第j行给出了编号为j-1的物品的基本数据,每行有3个非负整数: v p q<br /> (其中v表示该物品的价格(v<10000),p表示该物品的重要度(1~5),q表示该物品是主件还是附件。如果q=0,表示该物品为主件,如果q>0,表示该物品为附件,q是所属主件的编号)<br />

输出文件budget.out只有一个正整数,为不超过总钱数的物品的价格与重要度乘积的总和的最大值(<200000)。

1000 5 800 2 0 400 5 1 300 5 1 400 3 0 500 2 0

2200

0

 

 

2017-06-03 21:39:01

1

128

N

1

1

0

1813

【动态规划】对抗赛(compete)

程序设计对抗赛设有N0<N≤50的整数)个价值互不相同的奖品,每个奖品的价值分别为S1S2S3……Sn(均为不超过100的正整数)。现将它们分给甲乙两队,为了使得甲乙两队得到相同价值的奖品,必须将这N个奖品分成总价值相等的两组。<br /> 编程要求:对给定NN个奖品的价值,求出将这N个奖品分成价值相等的两组,共有多少种分法?<br /> 例如:N = 5S1S2S3……Sn分别为13589<br /> 则可分为{139}{58}<br /> 仅有1种分法;<br /> 例如:N = 7S1S2S3……Sn分别为1234567<br /> 则可分为:<br /> {1,6,7}{2,3,4,5}<br /> {2,5,7}{1,3,4,6}<br /> {3,4,7}{1,2,5,6}<br /> {1,2,4,7}{3,5,6}<br /> 4种分法。<br />

输入文件中包含NS1S2S3……Sn。(每两个相邻的数据之间有一个空格隔开)。

输出文件包含一个整数,表示多少种分法的答案,数据若无解,则输出0

7 1 2 3 4 5 6 7

4

0

 

 

2017-06-03 21:38:53

1

128

N

0

0

0

1814

【动态规划】演讲大厅安排(hall)

<p> 有一个演讲大厅需要我们管理,演讲者们事先定好了需要演讲的起始时间和中止时间。我们想让演讲大厅得到最大可能的使用。我们要接受一些预定而拒绝其他的预定,目标是使演讲者使用大厅的时间最长。假设在某一时刻一个演讲结束,另一个演讲就可以立即开始。 </p> <p> 【编程任务】<br /> 1、从文本文件hall.in中读入演讲者的申请。<br /> 2、计算演讲大厅最大可能的使用时间。<br /> 3、将结果写入文件hall.out </p>

输入文件hall.in第一行为一个整数NN≤5000,表示申请的数目。<br /> 以下n行每行包含两个整数pk1 ≤ p < k ≤ 30000,表示这个申请的起始时间和中止时间。<br />

输出文件hall.out包含一个整数,表示大厅最大可能的使用时间。

12 1 2 3 5 0 4 6 8 7 13 4 6 9 10 9 12 11 14 15 19 14 16 18 20

16

0

 

 

2017-06-03 21:38:46

1

128

N

0

0

0

1815

【动态规划】火车票(railway)

<p> EkaterinburgSverdlovsk的火车线路上有若干个站点。这条线路可以近似的表示为一条线段,火车站就是线段上的点。线路始于Ekaterinburg,终于SverdlovskEkaterinburg被标号为1Sverdlovsk被标号为n。(n为整条线路上的站点数) </p> <p> <img src="/JudgeOnline/upload/image/20170603/20170603205601_57385.png" alt="" /> </p> <p> 如果两站的间距超过L3,则无直达车票。所以有时可能有必要买多张票,通过转车的方式,从一个站到达另一个站。<br /> 例如,在上面的图中,有7个站点。2号站点到6号站点的距离超过L3,不能买直达票。存在若干种中转的方法,其中的一种是买两张票:先花费C22号站到达3号站,然后花费C33号站到6号站,一种花费C2+C3<br /> 你的任务是,找出一种最经济的中转方案。 </p>

<p> 第一行 6个整数L1, L2, L3, C1, C2, C31<=L1<L2<L3<=10^9, 1<=C1<C2<C3<=10^9),中间用空格分隔。 </p> <p> 第二行一个整数n2<=n<=100),表示线路上的车站数。<br /> 第三行两个整数st,分别是起点和终点的编号。注意:s不一定小于t<br /> 以下的n-1行,按据Ekaterinburg远近,每行描述了一个车站的位置。它包含一个整数,表示该车站距Ekaterinburg的距离。<br /> 任意两个车站的距离不超过10^9,任意两个相邻的车站的距离不超过L3 </p>

一个整数,表示从给定的一个站到给定的另一个站的最小花费。

3 6 8 20 30 40 7 2 6 3 7 8 13 15 23

70

0

 

 

2017-06-03 21:38:39

1

128

N

0

0

0

1816

【动态规划】单词的划分(word)

有一个很长的由小写字母组成字符串。为了便于对这个字符串进行分析,需要将它划分成若干个部分,每个部分称为一个单词。出于减少分析量的目的,我们希望划分出的单词数越少越好。你就是来完成这一划分工作的。

从文本文件word.in中读入数据。<br /> 第一行,一个字符串。(字符串的长度不超过100<br /> 第二行一个整数n,表示单词的个数。(n<=100<br /> 3~n+2行,每行列出一个单词。<br />

一个整数,表示字符串可以被划分成的最少的单词数。

realityour 5 real reality it your our

2 (原字符串可拆成real+it+yourreality+our,由于reality+our仅为两个部分,因此最优解为2,另外注意,单词列表中的每个单词都可以重复使用多次,也可以不用)

0

 

 

2017-06-03 21:38:26

1

128

N

0

0

0

1817

【动态规划】饥饿的牛(hunger)

牛在饲料槽前排好了队。饲料槽依次用1N(1<=N<=2000)编号。每天晚上,一头幸运的牛根据约翰的规则,吃其中一些槽里的饲料。<br /> 约翰提供B个区间的清单。一个区间是一对整数start-end,1<=start<=end<=N,表示一些连续的饲料槽,比如1-3,7-8,3-4等等。牛可以任意选择区间,但是牛选择的区间不能有重叠。<br /> 当然,牛希望自己能够吃得越多越好。给出一些区间,帮助这只牛找一些区间,使它能吃到最多的东西。<br /> 在上面的例子中,1-33-4是重叠的;聪明的牛选择{1-37-8},这样可以吃到5个槽里的东西。<br />

第一行,整数B(1<=B<=1000)<br /> 2B+1行,每行两个整数,表示一个区间,较小的端点在前面。<br />

仅一个整数,表示最多能吃到多少个槽里的食物。

3 1 3 7 8 3 4

5

0

 

 

2017-06-03 21:38:20

1

128

N

0

0

0

1818

【动态规划】护卫队(convoy)

护卫车队在一条单行的街道前排成一队,前面河上是一座单行的桥。因为街道是一条单行道,所以任何车辆都不能超车。桥能承受一个给定的最大承载量。为了控制桥上的交通,桥两边各站一个指挥员。护卫车队被分成几个组,每组中的车辆都能同时通过该桥。当一组车队到达了桥的另一端,该端的指挥员就用电话通知另一端的指挥员,这样下一组车队才能开始通过该桥。每辆车的重量是已知的。任何一组车队的重量之和不能超过桥的最大承重量。被分在同一组的每一辆车都以其最快的速度通过该桥。一组车队通过该桥的时间是用该车队中速度最慢的车通过该桥所需的时间来表示的。要求计算出全部护卫车队通过该桥所需的最短时间值。

输入文件第一行包含三个正整数(用空格隔开),第一个整数表示该桥所能承受的最大载重量(用吨表示);第二个整数表示该桥的长度(用千米表示);第三个整数表示该护卫队中车辆的总数(n<1000)。接下来的几行中,每行包含两个正整数WS(用空格隔开)W表示该车的重量(用吨表示)S表示该车过桥能达到的最快速度(用千米/小时表示)。车子的重量和速度是按车子排队等候时的顺序给出的。

输出文件应该是一个实数,四舍五入精确到小数点后1位,表示整个护卫车队通过该桥所需的最短时间(用分钟表示)

100 5 10 40 25 50 20 50 20 70 10 12 50 9 70 49 30 38 25 27 50 19 70

75.0

0

 

 

2017-06-03 21:38:11

1

128

N

0

0

0

1819

【动态规划】数字游戏(game)

丁丁最近沉迷于一个数字游戏。这个游戏看似简单,但丁丁在研究了许多天之后却发觉原来在简单的规则下想要赢得这个游戏并不那么容易。游戏是这样的,在你面前有一圈整数(一共n个),你要按顺序将其分为m个部分,各部分内的数字相加,相加所得的m个结果对10取模后再相乘,最终得到一个数k。游戏的要求是使你所得的k最大或者最小。<br /> <p> 例如,对于下面这圈数字(n=4m=2): </p> <p> <img src="/JudgeOnline/upload/image/20170603/20170603210451_48813.png" alt="" /> </p> <p> 当要求最小值时,((2-1) mod 10)×((4+3) mod 10)=1×7=7,要求最大值时,为((2+4+3) mod 10)×(-1 mod 10)=9×9=81。特别值得注意的是,无论是负数还是正数,对10取模的结果均为非负值。<br /> 丁丁请你编写程序帮他赢得这个游戏。 </p>

输入文件第一行有两个整数,n1≤n≤50)和m1≤m≤9)。以下n行每行有一个整数,其绝对值不大于10<sup>4</sup>,按顺序给出圈中的数字,首尾相接。

输出文件有两行,各包含一个非负整数。第一行是你程序得到的最小值,第二行是最大值。<br />

4 2 4 3 -1 2

7 81

0

 

 

2017-06-03 21:38:00

1

128

N

0

0

0

1820

【动态规划】能量项链(energy)

Mars星球上,每个Mars人都随身佩带着一串能量项链。在项链上有N颗能量珠。能量珠是一颗有头标记与尾标记的珠子,这些标记对应着某个正整数。并且,对于相邻的两颗珠子,前一颗珠子的尾标记一定等于后一颗珠子的头标记。因为只有这样,通过吸盘(吸盘是Mars人吸收能量的一种器官)的作用,这两颗珠子才能聚合成一颗珠子,同时释放出可以被吸盘吸收的能量。如果前一颗能量珠的头标记为m,尾标记为r,后一颗能量珠的头标记为r,尾标记为n,则聚合后释放的能量为n<span>×</span>r<span>×</span>mMars单位),新产生的珠子的头标记为m,尾标记为n<br /> 需要时,Mars人就用吸盘夹住相邻的两颗珠子,通过聚合得到能量,直到项链上只剩下一颗珠子为止。显然,不同的聚合顺序得到的总能量是不同的,请你设计一个聚合顺序,使一串项链释放出的总能量最大。<br /> 例如:设N=44颗珠子的头标记与尾标记依次为(23) (35) (510) (102)。我们用记号表示两颗珠子的聚合操作,(j⊕k)表示第jk两颗珠子聚合后所释放的能量。则第41两颗珠子聚合后释放的能量为:<br /> (4⊕1)=10*2*3=60<br /> 这一串项链可以得到最优值的一个聚合顺序所释放的总能量为<br /> ((4⊕1)⊕2)⊕3=10*2*3+10*3*5+10*5*10=710<br />

输入文件energy.in的第一行是一个正整数N4≤N≤100),表示项链上珠子的个数。第二行是N个用空格隔开的正整数,所有的数均不超过1000。第i个数为第i颗珠子的头标记(1≤i≤N),当i<N时,第i颗珠子的尾标记应该等于第i+1颗珠子的头标记。第N颗珠子的尾标记应该等于第1颗珠子的头标记。<br /> 至于珠子的顺序,你可以这样确定:将项链放到桌面上,不要出现交叉,随意指定第一颗珠子,然后按顺时针方向确定其他珠子的顺序。<br />

输出文件energy.out只有一行,是一个正整数EE≤2.1*109),为一个最优聚合顺序所释放的总能量。

4 2 3 5 10

710

0

 

 

2017-06-03 21:37:53

1

128

N

7

7

0

1821

【动态规划】传纸条(message)

<p> 小渊和小轩是好朋友也是同班同学,他们在一起总有谈不完的话题。一次素质拓展活动中,班上同学安排做成一个mn列的矩阵,而小渊和小轩被安排在矩阵对角线的两端,因此,他们就无法直接交谈了。幸运的是,他们可以通过传纸条来进行交流。纸条要经由许多同学传到对方手里,小渊坐在矩阵的左上角,坐标(1,1),小轩坐在矩阵的右下角,坐标(m,n)。从小渊传到小轩的纸条只可以向下或者向右传递,从小轩传给小渊的纸条只可以向上或者向左传递。 </p> <p> 在活动进行中,小渊希望给小轩传递一张纸条,同时希望小轩给他回复。班里每个同学都可以帮他们传递,但只会帮他们一次,也就是说如果此人在小渊递给小轩纸条的时候帮忙,那么在小轩递给小渊的时候就不会再帮忙。反之亦然。<br /> 还有一件事情需要注意,全班每个同学愿意帮忙的好感度有高有低(注意:小渊和小轩的好心程度没有定义,输入时用0表示),可以用一个0-100的自然数来表示,数越大表示越好心。小渊和小轩希望尽可能找好心程度高的同学来帮忙传纸条,即找到来回两条传递路径,使得这两条路径上同学的好心程度只和最大。现在,请你帮助小渊和小轩找到这样的两条路径。 </p>

输入文件message.in的第一行有2个用空格隔开的整数mn,表示班里有mn列(1<=m,n<=50)。<br /> 接下来的m行是一个m*n的矩阵,矩阵中第ij列的整数表示坐在第ij列的学生的好心程度。每行的n个整数之间用空格隔开。<br />

输出文件message.out共一行,包含一个整数,表示来回两条路上参与传递纸条的学生的好心程度之和的最大值。

3 3 0 3 9 2 8 5 5 7 0

34

0

30%的数据满足:1<=m,n<=10<br /> 100%的数据满足:1<=m,n<=50<br />

 

2017-06-03 21:37:45

1

128

N

2

4

0

1822

【动态规划】筷子(chop)

A先生有很多双筷子。确切的说应该是很多根,因为筷子的长度不一,很难判断出哪两根是一双的。这天,A先生家里来了K个客人,A先生留下他们吃晚饭。加上A先生,A夫人和他们的孩子小A,共K+3个人。每人需要用一双筷子。A先生只好清理了一下筷子,共N根,长度为T1,T2,T3,……,TN.现在他想用这些筷子组合成K+3双,使每双的筷子长度差的平方和最小。(怎么不是和最小??这要去问A先生了,呵呵)

输入文件共有两行,第一行为两个用空格隔开的整数,表示N,K(1≤N≤100, 0<K<50),第二行共有N个用空格隔开的整数,为Ti.每个整数为150之间的数。

输出文件仅一行。如果凑不齐K+3双,输出-1,否则输出长度差平方和的最小值。

10 1 1 1 2 3 3 3 4 6 10 20

5

0

说明:<br /> 第一双 1 1<br /> 第二双 2 3<br /> 第三双 3 3<br /> 第四双 4 6<br /> (1-1)^2+(2-3)^2+(3-3)^2+(4-6)^2=5<br />

 

2017-06-03 21:37:36

1

128

N

1

4

0

1823

【动态规划】垃圾陷阱(well)

卡门——农夫约翰极其珍视的一条Holsteins奶牛——已经落了到垃圾井中。垃圾井是农夫们扔垃圾的地方,它的深度为D (2 <= D <= 100)英尺。<br /> 卡门想把垃圾堆起来,等到堆得与井同样高时,她就能逃出井外了。另外,卡门可以通过吃一些垃圾来维持自己的生命。<br /> 每个垃圾都可以用来吃或堆放,并且堆放垃圾不用花费卡门的时间。<br /> 假设卡门预先知道了每个垃圾扔下的时间t(0<t<=1000),以及每个垃圾堆放的高度h(1<=h<=25)和吃进该垃圾能维持生命的时间f(1<=f<=30),要求出卡门最早能逃出井外的时间,假设卡门当前体内有足够持续10小时的能量,如果卡门10小时内没有进食,卡门就将饿死。<br />

第一行为2个整数,D  G (1 <= G <= 100)G为被投入井的垃圾的数量。<br /> 第二到第G+1行每行包括3个整数:T(0<T<=1000),表示垃圾被投进井中的时间;F(1<= F<= 30),表示该垃圾能维持卡门生命的时间;和 H (1<= H<=25),该垃圾能垫高的高度。<br />

如果卡门可以爬出陷阱,输出一个整数表示最早什么时候可以爬出;否则输出卡门最长可以存活多长时间。

20 4 5 4 9 9 3 2 12 6 10 13 1 1

13

0

卡门堆放她收到的第一个垃圾:height=9<br /> 卡门吃掉她收到的第二个垃圾,使她的生命从10小时延伸到13小时;<br /> 卡门堆放第3个垃圾,height=19<br /> 卡门堆放第4个垃圾,height=20<br />

 

2017-06-03 21:37:23

1

128

N

1

1

0

1824

【动态规划】守望者的逃离(Noip2007)

恶魔猎手尤迪安野心勃勃,他背叛了暗夜精灵,率领深藏在海底的娜迦族企图叛变。守望者在与尤迪安的交锋中遭遇了围杀,被困在一个荒芜的大岛上。为了杀死守望者,尤迪安开始对这个荒岛施咒,这座岛很快就会沉下去。到那时,岛上的所有人都会遇难。守望者的跑步速度为17m/s,以这样的速度是无法逃离荒岛的。庆幸的是守望者拥有闪烁法术,可在1s内移动60m,不过每次使用闪烁法术都会消耗魔法值10点。守望者的魔法值恢复的速度为4/s,只有处在原地休息状态时才能恢复。<br /> 现在已知守望者的魔法初值M,他所在的初始位置与岛的出口之间的距离S,岛沉没的时间T。你的任务是写一个程序帮助守望者计算如何在最短的时间内逃离荒岛,若不能逃出,则输出守望者在剩下的时间内能走的最远距离。注意:守望者跑步、闪烁或休息活动均以秒(s)为单位,且每次活动的持续时间为整数秒。距离的单位为米(m)<br />

输入文件escape.in仅一行,包括空格隔开的三个非负整数M, S, T

输出文件escape.out包含两行:<br /> 1行为字符串“Yes”“No”(区分大小写),即守望者是否能逃离荒岛。<br /> 2行包含一个整数。第一行为“Yes”(区分大小写)时表示守望者逃离荒岛的最短时间;第一行为“No”(区分大小写)时表示守望者能走的最远距离。<br />

【输入样例1 39 200 4 【输入样例2 36 255 10

【输出样例1 No 197 【输出样例2 Yes 6

0

【限制】<br /> 30%的数据满足:1 <= T <= 10, 1 <= S <= 100<br /> 50%的数据满足:1 <= T <= 1000, 1 <= S <= 10000<br /> 100%的数据满足:1 <= T <= 300000, 0 <= M <= 1000, 1 <= S <= 108.<br />

 

2017-06-03 21:37:18

1

128

N

0

0

0

1825

【动态规划】矩阵取数游戏(Noip2007)

帅帅经常跟同学玩一个矩阵取数游戏:对于一个给定的n*m的矩阵,矩阵中的每个元素a<sub>ij</sub>均为非负整数。游戏规则如下:<br /> 1、每次取数时须从每行各取走一个元素,共n个。m次后取完矩阵所有元素;<br /> 2、每次取走的各个元素只能是该元素所在行的行首或行尾;<br /> 3、每次取数都有一个得分值,为每行取数的得分之和,每行取数的得分 = 被取走的元素值*2<sup>i</sup>,其中i表示第i次取数(从1开始编号);<br /> 4、游戏结束总得分为m次取数得分之和。<br /> 帅帅想请你帮忙写一个程序,对于任意矩阵,可以求出取数后的最大得分。<br />

输入文件game.in包括n+1行:<br /> 1行为两个用空格隔开的整数nm<br /> 2~n+1行为n*m矩阵,其中每行有m个用单个空格隔开的非负整数。<br />

输出文件game.out仅包含1行,为一个整数,即输入矩阵取数后的最大得分。

【输入样例1 2 3 1 2 3 3 4 2 【输入样例2 1 4 4 5 0 5 【输入样例3 2 10 96 56 54 46 86 12 23 88 80 43 16 95 18 29 30 53 88 83 64 67

【输出样例1 82 【输出样例2122 【输出样例3 316994

0

【输入输出样例1解释】<br /> 1次:第1行取行首元素,第2行取行尾元素,本次得分为1*21+2*21=6<br /> 2次:两行均取行首元素,本次得分为2*22+3*22=20<br /> <p> 3次:得分为3*23+4*23=56。总得分为6+20+56=82 </p> <p> 【限制】<br /> 60%的数据满足:1<=n, m<=30, 答案不超过10<sup>16</sup><br /> 100%的数据满足:1<=n, m<=80, 0<=a<sub>ij</sub><=1000 </p>

 

2017-06-03 21:37:12

1

128

N

1

2

0

1826

【队列】*的面积

<p> 编程计算由“*”号围成的下列图形的面积。面积计算方法是统计*号所围成的闭合曲线中水平线和垂直线交点的数目。如下图所示,在10*10的二维数组中,有“*”围住了15个点,因此面积为15 </p> <p> <img src="/JudgeOnline/upload/image/20170603/20170603214228_94758.bmp" alt="" /> </p>

0 0 0 0 0 0 0 0 0 0<br /> 0 0 0 0 1 1 1 0 0 0<br /> 0 0 0 0 1 0 0 1 0 0<br /> 0 0 0 0 0 1 0 0 1 0<br /> 0 0 1 0 0 0 1 0 1 0<br /> 0 1 0 1 0 1 0 0 1 0<br /> 0 1 0 0 1 1 0 1 1 0<br /> 0 0 1 0 0 0 0 1 0 0<br /> 0 0 0 1 1 1 1 1 0 0<br /> 0 0 0 0 0 0 0 0 0 0<br />

15

 

 

0

 

 

2017-06-03 21:48:23

1

128

N

12

23

0

1827

【队列】奇怪的电梯(lift)

大楼的每一层楼都可以停电梯,而且第i层楼(1<=i<=N)上有一个数字Ki0<=Ki<=N)。电梯只有四个按钮:开,关,上,下。上下的层数等于当前楼层上的那个数字。当然,如果不能满足要求,相应的按钮就会失灵。例如:3 3 1 2 5代表了KiK1=3,K2=3,……),从一楼开始。在一楼,按可以到4楼,按是不起作用的,因为没有-2楼。那么,从A楼到B楼至少要按几次按钮呢?

输入文件共有二行,第一行为三个用空格隔开的正整数,表示N,A,B(1≤N≤200, 1≤A,B≤N),第二行为N个用空格隔开的正整数,表示Ki

输出文件仅一行,即最少按键次数,若无法到达,则输出-1

5 1 5 3 3 1 2 5

3

0

 

 

2017-06-03 21:48:29

1

128

N

11

14

0

1828

【队列】产生数(Produce)

给出一个整数nn<=2000)和k个变换规则(k≤15)。规则:<br /> ① 1个数字可以变换成另1个数字;<br /> ② 规则中,右边的数字不能为零。<br /> 例如:n=234k=2规则为<br /> 2 → 5<br /> 3 → 6<br /> 上面的整数234经过变换后可能产生出的整数为(包括原数)2345342645644种不同的产生数。<br /> 求经过任意次的变换(0次或多次),能产生出多少个不同的整数。仅要求输出不同整数个数。<br />

n<br /> k<br /> x1 y1<br /> x2 y2<br /> … …<br /> xn yn<br />

格式为一个整数(满足条件的整数个数)。

234 2 2 5 3 6

4

0

 

 

2017-06-03 21:48:36

1

128

N

11

26

0

1829

【队列】家庭问题(family)

n个人,编号为1,2,……n,另外还知道存在K个关系。一个关系的表达为二元组(αβ)形式,表示αβ为同一家庭的成员。<br /> nkk个关系给出之后,求出其中共有多少个家庭、最大的家庭中有多少人?<br /> 例如:n6k3,三个关系为(1,2),(1,3)(4,5)<br /> 此时,6个人组成三个家庭,即:{1,2,3}为一个家庭,{4,5}为一个家庭,{6}单独为一个家庭,第一个家庭的人数为最多。<br />

文件的第一行为n,k二个整数(1≤n≤100)(用空格分隔)<br /> 接下来的k行,每行二个整数(用空格分隔)表示关系<br />

二个整数(分别表示家庭个数和最大家庭人数)

6 3 1 2 1 3 4 5

3 3

0

 

 

2017-06-03 21:48:42

1

128

N

8

10

0

1830

【二叉树】小球(drop)

<p> 许多的小球一个一个的从一棵满二叉树上掉下来组成FBTFull Binary Tree,满二叉树),每一时间,一个正在下降的球第一个访问的是非叶子节点。然后继续下降时,或者走右子树,或者走左子树,直到访问到叶子节点。决定球运动方向的是每个节点的布尔值。最初,所有的节点都是false,当访问到一个节点时,如果这个节点是false,则这个球把它变成true,然后从左子树走,继续它的旅程。如果节点是true,则球也会改变它为false,而接下来从右子树走。满二叉树的标记方法如下图: </p> <p> <img src="/JudgeOnline/upload/image/20170603/20170603220024_56193.bmp" alt="" /> </p> <p> 因为所有的节点最初为false,所以第一个球将会访问节点1,节点2和节点4,转变节点的布尔值后在在节点8停止。第二个球将会访问节点136,在节点12停止。明显地,第三个球在它停止之前,会访问节点125,在节点10停止。<br /> 现在你的任务是,给定FBT的深度D,和I,表示第I个小球下落,你可以假定I不超过给定的FBT的叶子数,写一个程序求小球停止时的叶子序号。 </p>

输入文件仅一行包含两个用空格隔开的整数DI。其中2<=D<=201<=I<=524288

对应输出第I个小球下落停止时的叶子序号。

4 2

12

0

 

 

2017-06-03 22:14:52

1

128

N

0

0

0

1831

【二叉树】二叉树遍历(flist)

树和二叉树基本上都有先序、中序、后序、按层遍历等遍历顺序,给定中序和其它一种遍历的序列就可以确定一棵二叉树的结构。<br /> 假定一棵二叉树一个结点用一个字符描述,现在给出中序和按层遍历的字符串,求该树的先序遍历字符串。<br />

输入文件flist.in共两行,每行是由字母组成的字符串(一行的每个字符都是唯一的),分别表示二叉树的中序遍历和按层遍历的序列。

输出文件flist.out就一行,表示二叉树的先序序列。

DBEAC ABCDE

ABDEC

0

 

 

2017-06-03 22:14:58

1

128

N

0

0

0

1832

【二叉树】FBI(fbi)

我们可以把由“0”“1”组成的字符串分为三类:全“0”串称为B串,全“1”串称为I串,既含“0”又含“1”的串则称为F串。<br /> FBI树是一种二叉树1,它的结点类型也包括F结点,B结点和I结点三种。由一个长度为2<sup>N</sup>“01”S可以构造出一棵FBIT,递归的构造方法如下:<br /> T的根结点为R,其类型与串S的类型相同;<br /> 若串S的长度大于1,将串S从中间分开,分为等长的左右子串S1S2;由左子串S1构造R的左子树T1,由右子串S2构造R的右子树T2<br /> 现在给定一个长度为2<sup>N</sup>“01”串,请用上述构造方法构造出一棵FBI树,并输出它的后序遍历序列。<br />

输入文件fbi.in的第一行是一个整数N0 <= N <= 10),第二行是一个长度为2<sup>N</sup>“01”串。

输出文件fbi.out包括一行,这一行只包含一个字符串,即FBI树的后序遍历序列。

3 10001011

IBFBBBFIBFIIIFF

0

对于40%的数据,N <= 2<br /> <p> 对于100%的数据,N <= 10 </p> <p> <img src="/JudgeOnline/upload/image/20170603/20170603220557_37099.bmp" alt="" /> </p>

 

2017-06-03 22:15:03

1

128

N

0

0

0

1833

【二叉树】二叉树输出(btout)

树的凹入表示法主要用于树的屏幕或打印输出,其表示的基本思想是兄弟间等长,一个结点的长度要不小于其子结点的长度。二叉树也可以这样表示,假设叶结点的长度为1,一个非叶结点的长度等于它的左右子树的长度之和。<br /> 一棵二叉树的一个结点用一个字母表示(无重复),输出时从根结点开始:<br /> 每行输出若干个结点字符(相同字符的个数等于该结点长度),<br /> 如果该结点有左子树就递归输出左子树;<br /> <p> 如果该结点有右子树就递归输出右子树。 </p> <p> 假定一棵二叉树一个结点用一个字符描述,现在给出先序和中序遍历的字符串,用树的凹入表示法输出该二叉树。 </p>

输入文件btout.in共两行,每行是由字母组成的字符串(一行的每个字符都是唯一的),分别表示二叉树的先序遍历和中序遍历的序列。

输出文件btout.out的行数等于该树的结点数,每行的字母相同。

ABCDEFG CBDAFEG

AAAA BB C D EE F G

0

 

 

2017-06-03 22:15:08

1

128

N

0

0

0

1834

【二叉树】查找二叉树(tree_a)

<p> 已知一棵二叉树用邻接表结构存储,中序查找二叉树中值为x的结点,并指出是第几个结点。例:如图二叉树的数据文件的数据格式如下 </p> <p> <img src="/JudgeOnline/upload/image/20170603/20170603221021_47855.png" alt="" /> </p>

<span style="line-height:14.4px;">第一行n为二叉树的结点个树,n<=100;第二行x表示要查找的结点的值;以下第一列数据是各结点的值,第二列数据是左儿子结点编号,第三列数据是右儿子结点编号。</span>

<span style="line-height:14.4px;">输出一个数即查找的结点编号。</span>

7 15 5 2 3 12 4 5 10 0 0 29 0 0 15 6 7 8 0 0 23 0 0

4

0

 

 

2017-06-03 22:15:14

1

128

N

0

0

0

1835

【二叉树】对称二叉树(tree_c)

如果二叉树的左右子树的结构是对称的,即两棵子树皆为空,或者皆不空,则称该二叉树是对称的。编程判断给定的二叉树是否对称.<br /> <p> 例:如下图中的二叉树T1是对称的,T2是不对称的。 </p> <p> <img src="/JudgeOnline/upload/image/20170603/20170603221311_72577.png" alt="" /> </p> <p> 二叉树用顺序结构给出,若读到#则为空,二叉树T1=ABCDET2=ABCD#E,如果二叉树是对称的,输出“Yes”,反之输出“No” </p>

ABCDE

Yes

 

 

0

 

 

2017-06-03 22:15:19

1

128

N

0

0

0

1836

【堆】最小函数值(minval)

n个函数,分别为F1,F2,...,Fn。定义Fi(x)=Ai*x^2+Bi*x+Ci(x∈N*)。给定这些AiBiCi,请求出所有函数的所有函数值中最小的m个(如有重复的要输出多个)。

第一行输入两个正整数nm<br /> 以下n行每行三个正整数,其中第i行的三个数分别位AiBiCi。输入数据保证Ai<=10Bi<=100Ci<=10 000<br />

输出将这n个函数所有可以生成的函数值排序后的前m个元素。<br /> m个数应该输出到一行,用空格隔开。<br />

3 10 4 5 3 3 4 5 1 7 1

9 12 12 19 25 29 31 44 45 54

0

n,m<=10 000

 

2017-06-03 22:18:48

1

128

N

0

0

0

1837

【图的遍历】珍珠(bead)

<p style="text-align:left;"> n颗形状和大小都一致的珍珠,它们的重量都不相同。n为整数,所有的珍珠从1n编号。<br /> 你的任务是发现哪颗珍珠的重量刚好处于正中间,即在所有珍珠的重量中,该珍珠的重量列(n+1)/2位。<br /> 下面给出将一对珍珠进行比较的办法:<br /> 给你一架天平用来比较珍珠的重量,我们可以比出两个珍珠哪个更重一些,在作出一系列的比较后,我们可以将某些肯定不具备中间重量的珍珠拿走。<br /> 例如,下列给出对5颗珍珠进行四次比较的情况:<br /> 1、珍珠2比珍珠1<br /> 2、珍珠4比珍珠3<br /> 3、珍珠5比珍珠1<br /> 4、珍珠4比珍珠2<br /> 根据以上结果,虽然我们不能精确地找出哪个珍珠具有中间重量,<br /> 但我们可以肯定珍珠1和珍珠4不可能具有中间重量,<br /> 因为珍珠245比珍珠1重,而珍珠123比珍珠4轻,所以我们可以移走这两颗珍珠。<br /> 写一个程序统计出共有多少颗珍珠肯定不会是中间重量。 </p>

<p> 输入文件第一行包含两个用空格隔开的整数NM </p> <p> 其中1<=N<=99,且N为奇数,M表示对珍珠进行的比较次数, </p> <p> 接下来的M行每行包含两个用空格隔开的整数xy,表示珍珠x比珍珠y重。 </p>

输出文件仅一行包含一个整数,表示不可能是中间重量的珍珠的总数。

5 4 2 1 4 3 5 1 4 2

2

0

 

 

2018-03-26 17:16:20

1

128

N

13

13

0

1838

【图的遍历】铲雪车(snow)

<p> 随着白天越来越短夜晚越来越长,我们不得不考虑铲雪问题了。 </p> <p> 整个城市所有的道路都是双车道,因为城市预算的削减,整个城市只有1辆铲雪车。 </p> <p> 铲雪车只能把它开过的地方(车道)的雪铲干净,无论哪儿有雪,铲雪车都得从停放的地方出发,游历整个城市的街道。 </p> <p> 现在的问题是:最少要花多少时间去铲掉所有道路上的雪呢? </p>

<p> 输入数据的第1行表示铲雪车的停放坐标(x,y),xy为整数,单位为米。 </p> <p> 下面最多有100行,每行给出了一条街道的起点坐标和终点坐标,所有街道都是笔直的,且都是双向一个车道。 </p> <p> 铲雪车可以在任意交叉口、或任何街道的末尾任意转向,包括转U型弯。 </p> <p> 铲雪车铲雪时前进速度为20 km/h,不铲雪时前进速度为50 km/h </p> 保证:铲雪车从起点一定可以到达任何街道。<br />

铲掉所有街道上的雪并且返回出发点的最短时间,精确到分种。

0 0 0 0 10000 10000 5000 -10000 5000 10000 5000 10000 10000 10000

3:55

0

【注解】<br /> 3小时55分钟<br />

 

2018-03-26 17:10:26

1

128

N

11

11

0

1839

【图的遍历】骑马修栅栏(fence)

农民John每年有很多栅栏要修理。他总是骑着马穿过每一个栅栏并修复它破损的地方。<br /> John是一个与其他农民一样懒的人。他讨厌骑马,因此从来不两次经过一个一个栅栏。你必须编一个程序,读入栅栏网络的描述,并计算出一条修栅栏的路径,使每个栅栏都恰好被经过一次。John能从任何一个顶点(即两个栅栏的交点)开始骑马,在任意一个顶点结束。<br /> 每一个栅栏连接两个顶点,顶点用1500标号(虽然有的农场并没有500个顶点)。一个顶点上可连接任意多(>=1)个栅栏。所有栅栏都是连通的(也就是你可以从任意一个栅栏到达另外的所有栅栏)<br /> 你的程序必须输出骑马的路径(用路上依次经过的顶点号码表示)。我们如果把输出的路径看成是一个500进制的数,那么当存在多组解的情况下,输出500进制表示法中最小的一个 (也就是输出第一个数较小的,如果还有多组解,输出第二个数较小的,等等)。输入数据保证至少有一个解。<br />

1: 一个整数F(1 <= F <= 1024),表示栅栏的数目<br /> 2F+1: 每行两个整数i, j(1 <= i,j <= 500)表示这条栅栏连接ij号顶点。<br />

输出应当有F+1行,每行一个整数,依次表示路径经过的顶点号。注意数据可能有多组解,但是只有上面题目要求的那一组解是认为正确的。

9 1 2 2 3 3 4 4 2 4 5 2 5 5 6 5 7 4 6

1 2 3 4 2 5 4 6 5 7

0

 

 

2017-06-03 22:26:02

1

128

N

12

30

0

1840

【最短路径】信使(msner)

<p> 战争时期,前线有n个哨所,每个哨所可能会与其他若干个哨所之间有通信联系。 </p> <p> 信使负责在哨所之间传递信息,当然,这是要花费一定时间的(以天为单位)。 </p> <p> 指挥部设在第一个哨所。当指挥部下达一个命令后,指挥部就派出若干个信使向与指挥部相连的哨所送信。 </p> <p> 当一个哨所接到信后,这个哨所内的信使们也以同样的方式向其他哨所送信。直至所有n个哨所全部接到命令后,送信才算成功。因为准备充足,每个哨所内都安排了足够的信使(如果一个哨所与其他k个哨所有通信联系的话,这个哨所内至少会配备k个信使)。 </p> <p> 现在总指挥请你编一个程序,计算出完成整个送信过程最短需要多少时间。 </p>

<p> 输入文件msner.in,第1行有两个整数nm,中间用1个空格隔开,分别表示有n个哨所和m条通信线路。1<=n<=100 </p> <p> 2m+1行:每行三个整数ijk,中间用1个空格隔开,表示第i个和第j个哨所之间存在通信线路,且这条线路要花费k天。 </p>

<p> 输出文件msner.out,仅一个整数,表示完成整个送信过程的最短时间。 </p> <p> 如果不是所有的哨所都能收到信,就输出-1 </p>

4 4 1 2 4 2 3 7 2 4 1 3 4 6

11

0

 

 

2018-03-29 16:41:46

1

128

N

25

25

0

1841

【最短路径】最优乘车(travel)

<p> H城是一个旅游胜地,每年都有成千上万的人前来观光。为方便游客,巴士公司在各个旅游景点及宾馆,饭店等地都设置了巴士站并开通了一些单程巴士线路。每条单程巴士线路从某个巴士站出发,依次途经若干个巴士站,最终到达终点巴士站。 </p> <p> 一名旅客最近到H城旅游,他很想去S公园游玩,但如果从他所在的饭店没有一路巴士可以直接到达S公园,则他可能要先乘某一路巴士坐几站,再下来换乘同一站台的另一路巴士, 这样换乘几次后到达S公园。 </p> 现在用整数1,2,…N H城的所有的巴士站编号,约定这名旅客所在饭店的巴士站编号为1S公园巴士站的编号为N<br /> 写一个程序,帮助这名旅客寻找一个最优乘车方案,使他在从饭店乘车到S公园的过程<br /> 中换车的次数最少。<br />

输入文件是travel.in。文件的第一行有两个数字MN(1<=M<=100 1<N<=500),表示开通了M条单程巴士线路,总共有N个车站。从第二行到第M刊行依次给出了第1条到第M条巴士线路的信息。其中第i+1行给出的是第i条巴士线路的信息,从左至右按运行顺序依次给出了该线路上的所有站号相邻两个站号之间用一个空格隔开。

输出文件是travel.out,文件只有一行。如果无法乘巴士从饭店到达S公园,则输出"N0",否则输出你的程序所找到的最少换车次数,换车次数为0表示不需换车即可到达。

3 7 6 7 4 7 3 6 2 1 3 5

2

0

 

 

2018-04-01 12:49:37

2

128

N

6

51

0

1842

【最短路径】最短路径(shopth)

给出一个有向图G=(V, E),和一个源点v<sub>0</sub>∈V,请写一个程序输出v<sub>0</sub>和图G中其它顶点的最短路径。只要所有的有向环权值和都是正的,我们就允许图的边有负值。顶点的标号从1nn为图G的顶点数)。

1行:一个正数n2<=n<=80),表示图G的顶点总数。<br /> 2行:一个整数,表示源点v<sub>0</sub>v0∈Vv<sub>0</sub>可以是图G中任意一个顶点)。<br /> 3至第n+2行,用一个邻接矩阵W给出了这个图。<br />

共包含n-1行,按照顶点编号从小到大的顺序,每行输出源点v0到一个顶点的最短距离。每行的具体格式参照样例。

5 1 0 2 - - 10 - 0 3 - 7 - - 0 4 - - - - 0 5 - - 6 - 0

(1 -> 2) = 2 (1 -> 3) = 5 (1 -> 4) = 9 (1 -> 5) = 9

0

<p> 样例所对应的图如下: </p> <p> <img src="/JudgeOnline/upload/image/20170603/20170603223322_76309.bmp" alt="" /> </p>

 

2017-06-03 22:46:05

1

128

N

7

7

0

1843

【最短路径】热浪(heatwv)

德克萨斯纯朴的民眾们这个夏天正在遭受巨大的热浪!!!他们的德克萨斯长角牛吃起来不错,可是他们并不是很擅长生產富含奶油的乳製品。Farmer John此时以先天下之忧而忧,后天下之乐而乐的精神,身先士卒地承担起向德克萨斯运送大量的营养冰凉的牛奶的重任,以减轻德克萨斯人忍受酷暑的痛苦。<br /> FJ已经研究过可以把牛奶从威斯康星运送到德克萨斯州的路线。这些路线包括起始点和终点先一共经过T (1 <= T <= 2,500)个城镇,方便地标号為1T。除了起点和终点外的每个城镇由两条双向道路连向至少两个其它的城镇。每条道路有一个通过费用(包括油费,过路费等等)。<br /> 给定一个地图,包含C (1 <= C <= 6,200)条直接连接2个城镇的道路。每条道路由道路的起点Rs,终点Re (1 <= Rs <= T; 1 <= Re <= T),和花费(1 <= Ci <= 1,000)组成。求从起始的城镇Ts (1 <= Ts <= T)到终点的城镇Te(1 <= Te <= T)最小的总费用。<br />

第一行: 4个由空格隔开的整数: T, C, Ts, Te<br /> 2到第C+1: i+1行描述第i条道路。有3个由空格隔开的整数: Rs, ReCi<br />

一个单独的整数表示从TsTe的最小总费用。数据保证至少存在一条道路。

7 11 5 4 2 4 2 1 4 3 7 2 2 3 4 3 5 7 5 7 3 3 6 1 1 6 3 4 2 4 3 5 6 3 7 2 1

7

0

【样例说明】<br /> 5->6->1->4 (3 + 1 + 3)<br />

 

2017-06-03 22:45:59

1

128

N

13

17

0

1844

【最短路径】分糖果(candy)

童年的我们,将和朋友分享美好的事物作为自己的快乐。这天,C小朋友得到了Plenty of candies,将要把这些糖果分给要好的朋友们。已知糖果从一个人传给另一个人需要1 秒的时间,同一个小朋友不会重复接受糖果。由于糖果足够多,如果某时刻某小朋友接受了糖果,他会将糖果分成若干份,分给那些在他身旁且还没有得到糖果的小朋友们,而且自己会吃一些糖果。由于嘴馋,小朋友们等不及将糖果发完,会在得到糖果后边吃边发。每个小朋友从接受糖果到吃完糖果需要m秒的时间。那么,如果第一秒C小朋友开始发糖,第多少秒所有小朋友都吃完了糖呢?

第一行为三个数npc,为小朋友数、关系数和C小朋友的编号。<br /> 第二行为一个数m,表示小朋友吃糖的时间。<br /> 下面p行每行两个整数,表示某两个小朋友在彼此身旁。<br />

一个数,为所有小朋友都吃完了糖的时间。

4 3 1 2 1 2 2 3 1 4

5

0

【样例解释】<br /> 第一秒,糖在1手上。第二秒,糖传到了24的手中。第三秒,糖传到了3的手中,此时1吃完了。第四秒,24吃完了。第五秒,3吃完了。所以答案是5<br /> 【限制】<br /> 40%的数据满足:1<=n<=100<br /> 60%的数据满足:1<=n<=1000<br /> 100%的数据满足:1<=n<=100000<br /> m<=n*(n-1)/2,不会有同一个关系被描述多次的情况。<br />

 

2018-04-16 12:38:40

1

128

N

4

7

0

1845

【图的连通性】刻录光盘(cdrom)

FJOI2010夏令营快要结束的时候,很多营员提出来要把整个夏令营期间的资料刻录成一张光盘给大家,以便大家回去后继续学习。组委会觉得这个主意不错!可是组委会一时没有足够的空光盘,没法保证每个人都能拿到刻录上资料的光盘,怎么办呢?!<br /> DYJ分析了一下所有营员的地域关系,发现有些营员是一个城市的,其实他们只需要一张就可以了,因为一个人拿到光盘后,其他人可以带着U盘之类的东西去拷贝啊!<br /> 他们愿意某一些人到他那儿拷贝资料,当然也可能不愿意让另外一些人到他那儿拷贝资料,这与我们FJOI宣扬的团队合作精神格格不入!!!<br /> 现在假设总共有N个营员(2<=N<=200),每个营员的编号为1~NDYJ给每个人发了一张调查表,让每个营员填上自己愿意让哪些人到他那儿拷贝资料。当然,如果A愿意把资料拷贝给B,而B又愿意把资料拷贝给C,则一旦A获得了资料,则BC都会获得资料。<br /> 现在,请你编写一个程序,根据回收上来的调查表,帮助DYJ计算出组委会至少要刻录多少张光盘,才能保证所有营员回去后都能得到夏令营资料?<br />

先是一个数N,接下来的N行,分别表示各个营员愿意把自己获得的资料拷贝给其他哪些营员。即输入数据的第i+1行表示第i个营员愿意把资料拷贝给那些营员的编号,以一个0结束。如果一个营员不愿意拷贝资料给任何人,则相应的行只有10,一行中的若干数之间用一个空格隔开。

 

5 2 4 3 0 4 5 0 0 0 1 0

1

0

 

 

2017-06-03 22:49:04

1

128

N

1

1

0

1846

【并查集】团伙(group)

在某城市里住着n个人,任何两个认识的人不是朋友就是敌人,而且满足:<br /> 1、我朋友的朋友是我的朋友;<br /> 2、我敌人的敌人是我的朋友;<br /> 所有是朋友的人组成一个团伙。告诉你关于这n个人的m条信息,即某两个人是朋友,或者某两个人是敌人,请你编写一个程序,计算出这个城市最多可能有多少个团伙?<br />

1行为nm1<n<1000,1<=m<=100 000<br /> 以下m行,每行为p x yp的值为01p0时,表示xy是朋友,p1时,表示xy是敌人。<br />

一个整数,表示这n个人最多可能有几个团伙。

6 4 1 1 4 0 3 5 0 4 6 1 1 2

3

0

 

 

2017-06-03 22:59:21

1

128

N

7

10

0

1847

【并查集】打击犯罪(black)

某个地区有n(n<=1000)个犯罪团伙,当地警方按照他们的危险程度由高到低给他们编号为1-n,他们有些团伙之间有直接联系,但是任意两个团伙都可以通过直接或间接的方式联系,这样这里就形成了一个庞大的犯罪集团,犯罪集团的危险程度由集团内的犯罪团伙数量唯一确定,而与单个犯罪团伙的危险程度无关(该犯罪集团的危险程度为n)。现在当地警方希望花尽量少的时间(即打击掉尽量少的团伙),使得庞大的犯罪集团分离成若干个较小的集团,并且他们中最大的一个的危险程度不超过n/2。为达到最好的效果,他们将按顺序打击掉编号1k的犯罪团伙,请编程求出k的最小值。

第一行一个正整数n。接下来的n行每行有若干个正整数,第一个整数表示该行除第一个外还有多少个整数,若第i行存在正整数k,表示ik两个团伙可以直接联系。

一个正整数,为k的最小值

7 2 2 5 3 1 3 4 2 2 4 2 2 3 3 1 6 7 2 5 7 2 5 6

1

0

<p> 输出1(打击掉犯罪团伙) </p> <p> <img src="/JudgeOnline/upload/image/20170603/20170603225311_22513.bmp" alt="" /> </p>

 

2017-06-03 22:59:15

1

128

N

6

13

0

1848

【并查集】搭配购买(buy)

Joe觉得云朵很美,决定去山上的商店买一些云朵。商店里有n朵云,云朵被编号为12…...n,并且每朵云都有一个价值。但是商店老板跟他说,一些云朵要搭配来买才好,所以买一朵云则与这朵云有搭配的云都要买。<br /> 但是Joe的钱有限,所以他希望买的价值越多越好。<br />

1nmw,表示n朵云,m个搭配,Joew的钱。<br /> 2~n+1行,每行cidi表示i朵云的价钱和价值。<br /> n+2~n+1+m行,每行uivi,表示买ui就必须买vi,同理,如果买vi就必须买ui<br />

一行,表示可以获得的最大价值。

5 3 10 3 10 3 10 3 10 5 100 10 1 1 3 3 2 4 2

1

0

30%的数据保证:n<=100<br /> 50%的数据保证:n<=1,000m<=100w<=1,000<br /> 100%的数据保证:n<=10,0000<=m<=5000w<=10,000<br />

 

2017-06-03 22:59:10

1

128

N

7

13

0

1849

【并查集】家谱(gen)

现代的人对于本家族血统越来越感兴趣,现在给出充足的父子关系,请你编写程序找到某个人的最早的祖先。

输入文件由多行组成,首先是一系列有关父子关系的描述,其中每一组父子关系由二行组成,用#name的形式描写一组父子关系中的父亲的名字,用+name的形式描写一组父子关系中的儿子的名字;接下来用?name的形式表示要求该人的最早的祖先;最后用单独的一个$表示文件结束。规定每个人的名字都有且只有6个字符,而且首字母大写,且没有任意两个人的名字相同。最多可能有1000组父子关系,总人数最多可能达到50000人,家谱中的记载不超过30代。

按照输入文件的要求顺序,求出每一个要找祖先的人的祖先,格式:本人的名字+一个空格+祖先的名字+回车。

#George +Rodney #Arthur +Gareth +Walter #Gareth +Edward ?Edward ?Walter ?Rodney ?Arthur $

Edward Arthur Walter Arthur Rodney George Arthur Arthur

0

 

 

2017-06-03 22:59:05

2

128

N

7

7

0

1850

【最小生成树】局域网(net)

某个局域网内有n(n<=100)台计算机,由于搭建局域网时工作人员的疏忽,现在局域网内的连接形成了回路,我们知道如果局域网形成回路那么数据将不停的在回路内传输,造成网络卡的现象。因为连接计算机的网线本身不同,所以有一些连线不是很畅通,我们用f(i,j)表示i,j之间连接的畅通程度(f(i,j)<=1000)f(i,j)值越小表示i,j之间连接越通畅,f(i,j)0表示i,j之间无网线连接。现在我们需要解决回路问题,我们将除去一些连线,使得网络中没有回路,并且被除去网线的Σf(i,j)最大,请求出这个最大值。

第一行两个正整数n k<br /> 接下来的k行每行三个正整数i j m表示i,j两台计算机之间有网线联通,通畅程度为m<br />

一个正整数,Σf(i,j)的最大值

5 5 1 2 8 1 3 1 1 5 3 2 4 5 3 4 2

8

0

 

 

2017-06-03 23:08:33

1

128

N

7

12

0

1851

【最小生成树】繁忙的都市(city)

城市C是一个非常繁忙的大都市,城市中的道路十分的拥挤,于是市长决定对其中的道路进行改造。城市C的道路是这样分布的:城市中有n个交叉路口,有些交叉路口之间有道路相连,两个交叉路口之间最多有一条道路相连接。这些道路是双向的,且把所有的交叉路口直接或间接的连接起来了。每条道路都有一个分值,分值越小表示这个道路越繁忙,越需要进行改造。但是市政府的资金有限,市长希望进行改造的道路越少越好,于是他提出下面的要求:<br /> 1. 改造的那些道路能够把所有的交叉路口直接或间接的连通起来。<br /> 2. 在满足要求1的情况下,改造的道路尽量少。<br /> <p> 3. 在满足要求12的情况下,改造的那些道路中分值最大值尽量小。 </p> <p> 【编程任务】<br /> 作为市规划局的你,应当作出最佳的决策,选择那些道路应当被修建。 </p>

第一行有两个整数n,m表示城市有n个交叉路口,m条道路。接下来m行是对每条道路的描述,u, v, c表示交叉路口uv之间有道路相连,分值为c(1≤n≤3001≤c≤10000)

两个整数s, max,表示你选出了几条道路,分值最大的那条道路的分值是多少。

4 5 1 2 3 1 4 5 2 4 7 2 3 6 3 4 8

3 6

0

 

 

2017-06-03 23:08:28

1

128

N

10

10

0

1852

【最小生成树】联络员(liaison)

Tyvj已经一岁了,网站也由最初的几个用户增加到了上万个用户,随着Tyvj网站的逐步壮大,管理员的数目也越来越多,现在你身为Tyvj管理层的联络员,希望你找到一些通信渠道,使得管理员两两都可以联络(直接或者是间接都可以)。Tyvj是一个公益性的网站,没有过多的利润,所以你要尽可能的使费用少才可以。<br /> 目前你已经知道,Tyvj的通信渠道分为两大类,一类是必选通信渠道,无论价格多少,你都需要把所有的都选择上;还有一类是选择性的通信渠道,你可以从中挑选一些作为最终管理员联络的通信渠道。数据保证给出的通行渠道可以让所有的管理员联通。<br />

第一行nm表示Tyvj一共有n个管理员,有m个通信渠道<br /> 第二行到m+1行,每行四个非负整数,p,u,v,w p=1时,表示这个通信渠道为必选通信渠道;当p=2时,表示这个通信渠道为选择性通信渠道;u,v,w表示本条信息描述的是uv管理员之间的通信渠道,u可以收到v的信息,v也可以收到u的信息,w表示费用。<br />

最小的通信费用

5 6 1 1 2 1 1 2 3 1 1 3 4 1 1 4 1 1 2 2 5 10 2 2 5 5

9

0

【样例解释】<br /> 1-2-3-4-1存在四个必选渠道,形成一个环,互相可以到达。需要让所有管理员联通,需要联通2号和5号管理员,选择费用为5的渠道,所以总的费用为9<br /> 【注意】<br /> U,v之间可能存在多条通信渠道,你的程序应该累加所有u,v之间的必选通行渠道<br /> 【数据范围】<br /> 对于30%的数据,n<=10 m<=100<br /> 对于50%的数据, n<=200 m<=1000<br /> 对于100%的数据,n<=2000 m<=10000<br />

 

2017-06-03 23:08:23

1

128

N

6

14

0

1853

【最小生成树】连接格点(grid)

有一个MN列的点阵,相邻两点可以相连。一条纵向的连线花费一个单位,一条横向的连线花费两个单位。某些点之间已经有连线了,试问至少还需要花费多少个单位才能使所有的点全部连通。

第一行输入两个正整数mn<br /> 以下若干行每行四个正整数x1,y1,x2,y2,表示第x1行第y1列的点和第x2行第y2列的点已经有连线。输入保证|x1-x2|+|y1-y2|=1<br />

输出使得连通所有点还需要的最小花费。

2 2 1 1 2 1

3

0

30%数据:n*m<=1000<br /> 100%数据:m,n<=1000<br />

 

2017-06-03 23:08:17

1

128

N

4

7

0

1854

【拓扑排序】烦人的幻灯片(slides)

李教授将于今天下午作一次非常重要的演讲。不信的事他不是一个非常爱整洁的人,他把自己演讲要用的幻灯片随便堆在了一起。因此,演讲之前他不得不去整理这些幻灯片。作为一个讲求效率的学者,他希望尽可能简单地完成它。教授这次演讲一共要用n张幻灯片(n<=26),这n张幻灯片按照演讲要使用的顺序已经用数字1~n编了号。因为幻灯片是透明的,所以我们不能一下子看清每一个数字所对应的幻灯片。<br /> 现在我们用大写字母A,B,C……再次把幻灯片依次编号。你的任务是编写一个程序,把幻灯片的数字编号和字母编号对应起来,显然这种对应应该是唯一的;若出现多种对应的情况或是某些数字编号和字母编号对应不起来,我们称对应是无法实现的。<br />

文件的第一行只有一个整数n,表示有n张幻灯片,接下来的n行每行包括4个整数xmin,xmax,ymin,ymax(整数之间用空格分开)为幻灯片的坐标,这n张幻灯片按其在文件中出现的顺序从前到后依次编号为A,B,C……,再接下来的n行依次为n个数字编号的坐标x,y,显然在幻灯片之外是不会有数字的。

若是对应可以实现,输出文件应该包括n行,每一行为一个字母和一个数字,中间以一个空格隔开,并且每行以字母的升序排列,注意输出的字母要大写并且定格;反之,若是对应无法实现,在文件的第一行顶格输出None即可。首行末无多余的空格。<br />

4 6 22 10 20 4 18 6 16 8 20 2 18 10 24 4 8 9 15 19 17 11 7 21 11

A 4 B 1 C 2 D 3

0

 

 

2017-06-03 23:11:18

1

128

N

7

13

0

1855

【拓扑排序】病毒(virus)

有一天,小y突然发现自己的计算机感染了一种病毒!还好,小y发现这种病毒很弱,只是会把文档中的所有字母替换成其它字母,但并不改变顺序,也不会增加和删除字母。<br /> 现在怎么恢复原来的文档呢!小y很聪明,他在其他没有感染病毒的机器上,生成了一个由若干单词构成的字典,字典中的单词是按照字母顺序排列的,他把这个文件拷贝到自己的机器里,故意让它感染上病毒,他想利用这个字典文件原来的有序性,找到病毒替换字母的规律,再用来恢复其它文档。<br /> 现在你的任务是:告诉你被病毒感染了的字典,要你恢复一个字母串。<br />

第一行为整数K≤50000),表示字典中的单词个数。<br /> 以下K行,是被病毒感染了的字典,每行一个单词。<br /> 最后一行是需要你恢复的一串字母。<br /> 所有字母均为小写。<br />

输出仅一行,为恢复后的一串字母。当然也有可能出现字典不完整、甚至字典是错的情况,这时请输出一个0

6 cebdbac cac ecd dca aba bac cedab

abcde

0

 

 

2017-06-03 23:11:09

1

128

N

1

1

0

1856

plusplus

<p> <span style="font-size:16px;">有一个长度为n的序列bi,初始全为0pluto认为这个序列是优雅的当且仅当bi = ai(1<i<n)</span> </p> <p> <span style="font-size:16px;">现在有 m 组操作,对于第 i 组操作有三个参数</span><span style="font-size:16px;">l</span><sub><span style="font-size:16px;">i</span></sub><span style="font-size:16px;">r</span><sub><span style="font-size:16px;">i</span></sub><span style="font-size:16px;">d</span><sub><span style="font-size:16px;">i</span></sub><span style="font-size:16px;">,表示将b</span><sub><span style="font-size:16px;">li</span></sub><span style="font-size:16px;">……b</span><sub><span style="font-size:16px;">ri</span></sub><span style="font-size:16px;"> 都加上d</span><sub><span style="font-size:16px;">i</span></sub> </p> <span style="font-size:16px;">问是否存在一个k(0<=k<=n),经过 k 组操作后,序列 b 是优雅的,如果存在则输出满足条件的最小的k,否则输出’-1’</span><br />

<span style="font-size:16px;">一行两个数nm</span><br /> <span style="font-size:16px;"> 第二行 n 个数a</span><sub><span style="font-size:16px;">1</span></sub><span style="font-size:16px;">……a</span><sub><span style="font-size:16px;">n</span></sub><br /> <span style="font-size:16px;"> 接下来 m 行每行三个数l</span><sub><span style="font-size:16px;">i</span></sub><span style="font-size:16px;">r</span><sub><span style="font-size:16px;">i</span></sub><span style="font-size:16px;">d</span><sub><span style="font-size:16px;">i</span></sub><br />

<span style="font-size:16px;">一行一个数最小的满足条件的 k 或者是’-1’</span><br />

5 6 1 3 2 5 6 1 5 1 2 5 2 3 4 -1 4 5 3 1 5 2 1 5 -2

4

0

Explanation<br /> step0(bi)0 0 0 0 0<br /> step1(bi)1 1 1 1 1<br /> step2(bi)1 3 3 3 3<br /> step3(bi)1 3 2 2 3<br /> step4(bi)1 3 2 5 6<br /> step5(bi)3 5 4 7 8<br /> step6(bi)1 3 2 5 6<br /> Scoring<br /> • 对于50% 的数据,1 <= nm <= 1000<br /> • 对于80% 的数据,1 <= nm <= 10<sup>5</sup><br /> • 对于100% 的数据,1 <span><=</span> nm <span><=</span> 10<sup>6</sup>|a<sub>i</sub>| <span><=</span> 10<sup>18</sup>1 <span><=</span> l<sub>i</sub> <span><=</span> r<sub>i</sub> <span><=</span> n,、|d<sub>i</sub>| <span><=</span> 10<sup>9</sup><br />

清北学堂夏令营模拟考(一)

2017-07-16 18:21:46

1

256

N

0

0

0

1857

minimum

<span style="font-size:18px;">给出两个数ab,每次操作可以把a + 1 或把a x k</span><br /> <span style="font-size:18px;"> 问至少多少次操作可以使得a = b</span><br />

<span style="font-size:18px;">一行三个数a b k</span>

<span style="font-size:18px;">一行一个数ans,表示至少多少次操作可以使得a = b</span>

2 10 2

3

0

<span style="font-size:16px;">• 对于30% 的数据,1 <= a </span><span style="font-size:16px;"><=</span><span style="font-size:16px;"> b </span><span style="font-size:16px;"><=</span><span style="font-size:16px;"> 100</span><br /> <span style="font-size:16px;"> • 对于60% 的数据,1 </span><span style="font-size:16px;"><=</span><span style="font-size:16px;"> a </span><span style="font-size:16px;"><=</span><span style="font-size:16px;"> b </span><span style="font-size:16px;"><=</span><span style="font-size:16px;"> 10</span><sup><span style="font-size:16px;">6</span></sup><span style="font-size:16px;"></span><br /> <span style="font-size:16px;"> • 对于100% 的数据,1 </span><span style="font-size:16px;"><=</span><span style="font-size:16px;"> a </span><span style="font-size:16px;"><=</span><span style="font-size:16px;"> b </span><span style="font-size:16px;"><=</span><span style="font-size:16px;"> 10</span><sup><span style="font-size:16px;">18</span></sup><span style="font-size:16px;">0 </span><span style="font-size:16px;"><=</span><span style="font-size:16px;"> k </span><span style="font-size:16px;"><=</span><span style="font-size:16px;"> 10</span><sup><span style="font-size:16px;">18</span></sup><span style="font-size:16px;"></span><br />

清北学堂夏令营模拟考(一)

2017-07-16 18:21:18

1

256

N

1

1

0

1858

xor

<span style="font-size:16px;">给出n 个数a</span><sub><span style="font-size:16px;">1</span></sub><span style="font-size:18px;"><span style="font-size:16px;">…a</span><span style="font-size:16px;"></span></span><sub><span style="font-size:16px;">n</span></sub><span style="font-size:16px;">,求a</span><sub><span style="font-size:16px;">i </span></sub><span style="font-size:16px;">xor a</span><sub><span style="font-size:16px;">j </span></sub><span style="font-size:16px;"> (i不等于j) 的最大值。</span>

<span style="font-size:16px;">第一行一个数 n</span><br /> <span style="font-size:16px;"> 接下一行n 个数a1…an</span><br />

<span style="font-size:16px;">一行一个数ans, 表示a</span><sub><span style="font-size:16px;">i</span></sub><span style="font-size:16px;"> xor a</span><sub><span style="font-size:16px;">j</span></sub><span style="font-size:16px;">  (i不等于j) 的最大值</span>

4 3 6 7 7

5

0

对于30% 的数据,n <= 1000<br /> • 对于另外20% 的数据,数据保证最后的ans 一定是2k - 1<br /> • 对于70% 的数据,n <span><span><span><=</span></span></span> 10<sup>5</sup>0 <span><=</span> ai <span><=</span> 10<sup>7</sup><br /> • 对于100% 的数据,n <span><=</span> 10<sup>5</sup>0 <span><=</span> ai <span><=</span> 10<sup>16</sup><br />

清北学堂夏令营模拟考(一)

2017-07-16 18:20:39

1

256

N

0

0

0

1859

记者的烦恼

<p> 香港是祖国不可分割的一部分,我们伟大的长者来到了香港聆听群众的声音,我们的记者想要追上长者的步伐。 </p> <p> 那么问题来了,<s>挖掘机技术哪家强<span style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;"> </span></s><span style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;"> 给定x轴上的N0<N<100)条道路,每个<span style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;">道路</span>由它的二个端点a_Ib_I确定,I=1,2,……N.这些坐标都是区间(-999999)的整数。有些线段之间会相互交叠或覆盖。请你编写一个程序,从给出的<span style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;">道路</span>中去掉尽量少的<span style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;">道路</span>,使得剩下的<span style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;">道路</span>两两之间没有内部公共点。所谓的内部公共点是指一个点同时属于两条<span style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;">道路</span>且至少在其中一条<span style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;">道路</span>的内部(即除去端点的部分)。以帮助记者追上长者</span> </p>

<span style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;">输入第一行是一个整数N。接下来有N行,每行有二个空格隔开的整数,表示一条线段的二个端点的坐标。</span>

<span style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;">输出第一行是一个整数表示最多剩下的线段数。</span>

3 6 3 1 3 2 5

2

0

<p> <span style="color:#58666E;font-family:'Source Sans Pro', 'Helvetica Neue', Helvetica, Arial, 微软雅黑, 黑体, sans-serif;font-size:14px;background-color:#FFFFFF;">0<N<100</span> </p> <p> <span><span style="font-size:14px;background-color:#FFFFFF;">水题,是不是太暴力了</span></span> </p>

 

2017-07-16 20:55:03

1

128

N

2

2

0

1860

玩具谜题(toy)

<p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 小南有一套可爱的玩具小人,它们各有不同的职业。 </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 有一天,这些玩具小人把小南的眼镜藏了起来。小南发现玩具小人们围成了一个圈,它们有的面朝圈内,有的面朝圈外。如下图: </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> <img src="/JudgeOnline/upload/image/20170720/20170720191437_39467.png" alt="" width="598" height="500" title="" align="" /> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> <br /> </p> <div class="WordSection1"> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 这时 singer 告诉小南一个谜题:眼镜藏在我左数第 3 个玩具小人的右数第 1 个玩具小人的左数第 2 个玩具小人那里。” </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 小南发现,这个谜题中玩具小人的朝向非常关键,因为朝内和朝外的玩具小人的左右方向是相反的:面朝圈内的玩具小人,它的左边是顺时针方向,右边是逆时针方向;而面向圈外的玩具小人,它的左边是逆时针方向,右边是顺时针方向。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 小南一边艰难地辨认着玩具小人,一边数着:<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> “singer 朝内,左数第 3 个是 archer<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> “archer 朝外,右数第 1 个是 thinker </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> “thinker 朝外,左数第 2 个是 writer </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> “所以眼镜藏在 writer 这里!”<span></span> </p> <p class="MsoBodyText" style="margin-left:-3.85pt;text-align:justify;"> 虽然成功找回了眼镜,但小南并没有放心。如果下次有更多的玩具小人藏他的眼镜,或是谜题的长度更长,他可能就无法找到眼镜了。所以小南希望你写程序帮他解决类似的谜题。这样的谜题具体可以描述为:<span></span> </p> <p class="MsoBodyText" style="margin-left:-3.85pt;text-align:justify;">  <i>n </i>个玩具小人围成一圈,己知它们的职业和朝向。现在第 1 个玩具小人告诉小南一个包含 <i>m </i>条指令的谜题,其中第 <i>i </i>条指令形如左数/右数第 <i>s<sub>i</sub></i><i> </i>个玩具小人。你需要输出依次数完这些指令后,到达的玩具小人的职业。 </p> </div> <p> <br /> </p>

<p class="MsoNormal"> 从文件 <b><i>toy.in</i></b><b><i> </i></b>中读入数据。 </p> <p class="MsoBodyText" style="margin-left:0cm;"> 输入的第一行包含两个正整数 <i>n</i>,<i>m</i><i> </i>,表示玩具小人的个数和指令的条数。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 接下来 <i>n </i>行,每行包含一个整数和一个字符串,以<u>逆时针</u>为顺序给出每个玩具小人的朝向和职业。其中 0 表示朝向圈内, 1 表示朝向圈外。保证不会出现其他的数。字符串长度不超过 10 且仅由小写字母构成,字符串不为空,并且字符串两两不同。整数和字符串之间用一个空格隔开。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 接下来 <i>m </i>行,其中第 <i>i </i>行包含两个整数 <i>a</i><i>i</i>, <i>s</i><i>i </i>,表示第 <i>i </i>条指令。若 <i>a</i><i>i </i>= 0 ,表示向左数 <i>s</i><i>i </i>个人;若 <i>a</i><i>i </i>= 1 ,表示向右数 <i>s</i><i>i </i>个人。保证 <i>a</i><i>i </i>不会出现其他的数, 1 ≤ <i>s</i><i>i </i>< <i>n</i><i></i><span></span> </p>

<p class="MsoBodyText" style="margin-left:0cm;"> 输出到文件 <b><i>toy.out</i></b><b><i> </i></b>中。输出一个字符串,表示从第一个读入的小人开始,依次数完 <i>m </i>条指令后到达的小人的职业。 </p>

【样例一输入】 7 3 0 singer 0 reader 0 mengbier 1 thinker 1 archer 0 writer 1 mogician 0 3 1 1 0 2 【样例二输入】 10 10 1 c 0 r 0 p 1 d 1 e 1 m 1 t 1 y 1 u 0 v 1 7 1 1 1 4 0 5 0 3 0 1 1 6 1 2 0 8 0 4

【样例一输出】 writer 【样例二输出】 y

0

 

NOIP2016DAY1(一)

2017-07-20 19:25:04

1

512

N

7

8

0

1861

天天爱跑步(running)

<p class="MsoBodyText" style="margin-left:0cm;text-align:justify;">  C 同学认为跑步非常有趣,于是决定制作一款叫做《天天爱跑步》的游戏。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 《天 天爱跑步》是一个养成类游戏,需要玩家每天按时上线,完成打卡任务。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 这个游戏的地图可以看作一棵包含 <i>n </i>个结点和 <i>n </i> 1 条边的树,每条边连接两个结点,且任意两个结点存在一条路径互相可达。树上结点编号为从 1  <i>n </i>的连续正整数。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 现在有 <i>m </i>个玩家,第 <i>i </i>个玩家的起点为 <i>S<sub>i</sub> </i>,终点为 <i>T<sub>i</sub></i><i> </i>。每天打卡任务开始时,所 有玩家<u>在第</u><u> </u><u>0 </u><u></u>同时从<u>自己的起点</u>出发,以<u>每秒跑一条边</u>的速度,不间断地沿着 最短 路径向着<u>自己的终点</u>跑去,跑到终点后该玩家就算完成了打卡任务。(由于地图是一棵树,所以每个人的路径是唯一的)<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;">  C 想知道游戏的活跃度,所以在每个结点上都放置了一个观察员。在结点 <i>j </i>的 观 察员会选择在第 <i>W<sub>j</sub></i><i> </i>秒观察玩家,一个玩家能被这个观察员观察到当且仅当该玩家 在第 <i>W<sub>j</sub></i><i> </i>秒也<u>正好</u>到达了结点 <i>j </i>。小 C 想知道每个观察员会观察到多少人?<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> <u>注意:</u>我们认为一个玩家到达自己的终点后该玩家就会结束游戏,他不能等待一 段时间后再被观察员观察到。即对于把结点 <i>j </i>作为终点的玩家:若他在第 <i>W<sub>j</sub></i><i> </i><u></u>到达 终点,则在结点 <i>j </i>的观察员<u>不能观察到</u>该玩家;若他<u>正好</u>在第 <i>W<sub>j</sub></i><i> </i>秒到达终点,则在结 点 <i>j </i>的观察员<u>可以观察到</u>这个玩家。<span></span> </p>

<p class="MsoNormal" style="text-align:justify;"> 从文件 <b><i>running.in </i></b>中读入数据。 </p> <p class="MsoNormal"> 第一行有两个整数 <i>n </i> <i>m </i>。其中 <i>n </i>代表树的结点数量,同时也是观察员的数量,<i>m</i><i> </i>代表玩家的数量。 </p> <p class="MsoNormal" style="text-align:justify;"> 接下来 <i>n </i> 1 行每行两个整数 <i>u </i> <i>v </i>,表示结点 <i>u </i>到结点 <i>v </i>有一条边。<span></span> </p> <p class="MsoNormal" style="text-align:justify;"> 接下来一行 <i>n </i>个整数,其中第 <i>j </i>个整数为 <i>W<sub>j</sub></i><i> </i>,表示结点 <i>j </i>出现观察员的时间。<span></span> </p> <p class="MsoNormal" style="text-align:justify;"> 接下来 <i>m </i>行,每行两个整数 <i>S<sub>i</sub> </i> <i>T<sub>i</sub></i><i> </i>,表示一个玩家的起点和终点。<span></span> </p> <p class="MsoNormal" style="text-align:justify;"> 对于所有的数据,保证 <i>1 ≤ S<sub>i</sub> , T<sub>i</sub> ≤ n  0 ≤ W<sub>j</sub> ≤ n </i> </p>

<p class="MsoNormal" style="text-align:justify;"> 输出到文件 <b><i>running.out </i></b>中。 </p> <p class="MsoNormal" style="text-align:justify;"> 输出 1  <i>n </i>个整数,第 <i>j </i>个整数表示结点 <i>j </i>的观察员可以观察到多少人。 </p>

【样例 1 输入】 6 3 2 3 1 2 1 4 4 5 4 6 0 2 5 1 2 3 1 5 1 3 2 6 【样例 2 输入】 5 3 1 2 2 3 2 4 1 5 0 1 0 3 0 3 1 1 4 5 5

【样例 1 输出】 2 0 0 1 1 1 【样例 2 输出】 1 2 1 0 1

0

<p class="41" style="margin-left:0cm;text-align:justify;"> 【样例<span> 1 </span>说明】<span></span> </p> <p class="MsoNormal"> 对于 1 号点, <i>W</i><sub>1</sub> = 0 ,故只有起点为 1 号点的玩家才会被观察到,所以玩家 1 和玩家 2 被观察到,共 2 人被观察到。 </p> <p class="MsoNormal"> 对于 2 号点,没有玩家在第 2 秒时在此结点,共 0 人被观察到。 </p> <p class="MsoNormal"> 对于 3 号点,没有玩家在第 5 秒时在此结点,共 0 人被观察到。<span></span> </p> <p class="MsoNormal"> 对于 4 号点,玩家 1 被观察到,共 1 人被观察到。<span></span> </p> <p class="MsoNormal"> 对于 5 号点,玩家 1 被观察到,共 1 人被观察到。<span></span> </p> <p class="MsoNormal"> 对于 6 号点,玩家 3 被观察到,共 1 人被观察到。<span></span> </p>

NOIP2016DAY1(二)

2017-07-20 19:24:51

2

512

N

0

0

0

1862

换教室(classroom)

<p class="MsoBodyText" style="margin-left:0cm;"> 对于刚上大学的牛牛来说,他面临的第一个问题是如何根据实际情况申请合适的 课程。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 在可以选择的课程中,有 2<i>n</i> 节课程安排在 <i>n</i> 个时间段上。在第 <i>i</i><span> </span>( 1 ≤ <i>i </i>≤ <i>n </i>)个时间段上,两节内容相同的课程同时在不同的地点进行,其中,牛牛预先被安排在教室<i>c<sub>i</sub></i>上课,而另一节课程在教室 <i>d<sub>i</sub></i> 进行。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 在不提交任何申请的情况下,学生们需要按时间段的顺序依次完成所有的 <i>n</i><i> </i>节安排好的课程。如果学生想更换第 <i>i </i>节课程的教室,则需要提出申请。若申请通过,学生就可以在第 <i>i</i><i> </i>个时间段去教室 <i>d<sub>i</sub></i> 上课,否则仍然在教室 <i>d<sub>i</sub></i> 上课。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 由于更换教 室的需求太多,申请不一定能获得通过。通过计算,牛牛发现申请更换第 <i>i</i> 节课程的教室时,申请被通过的概率是一个己知的实数 <i>k<sub>i</sub></i><i> </i>,并且对于不同课程的申请,被通过的概率是互相独立的。<span></span> </p> <p class="MsoBodyText" style="margin-left:1.0pt;"> 学校规定,所有的申请只能在学期开始前一次性提交,并且每个人只能选择至多 <span>m </span>节课程进行申请。这意味着牛牛必须一次性决定是否申请更换每节课的教室,而 不能根据某些课程的申请结果来决定其他课程是否申请;牛牛可以申请自己最希望更 换教室的 <i>m </i>门课程,也可以<u>不用完</u> <i>m </i>个申请的机会,甚至可以一门课程都不申请。<span></span> </p> <p class="MsoBodyText" style="margin-left:1.0pt;"> 因为不同的课程可能会被安排在不同的教室进行,所以牛牛需要利用课间时间从 一间教室赶到另一间教室。<span></span> </p> <p class="MsoBodyText" style="margin-left:1.0pt;"> 牛牛所在的大学有 <i>v </i>个教室,有 <i>e </i>条道路。每条道路连接两间教室,并且是可<span></span> </p> <p class="MsoBodyText" style="margin-left:1.0pt;"> <u>双向通行</u>的。<span></span> </p> <p class="MsoBodyText" style="margin-left:1.0pt;text-align:justify;"> 由于道路的长度和拥堵程度不同,通过不同的道路耗费的体力可能会有所不同。当第 <i>i </i> 1 ≤ <i>i </i>≤ <i>n </i> 1 )节课结束后,牛牛就会从这节课的教室出发,选择一条耗费体力最少的<u>路径</u>前往下一节课的教室。现在牛牛想知道,申请哪几门课程可以使他因在教室间移动耗费的体力值的总和的期望值最小,请你帮他求出这个最小值。<span></span> </p> <p class="MsoBodyText" style="margin-left:1.0pt;"> 现在牛牛想知道,申请哪几门课程可以使他因在教室间移动耗费的体力值的总和的<u>期望值</u>最小,请你帮他求出这个最小值。<span></span> </p>

<div class="WordSection1"> <p class="MsoNormal"> 从文件 <b><i>classroom.in</i></b><b><i> </i></b>中读入数据。 </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 第一行四个整数 <i>n</i>, <i>m</i>, <i>v</i>, <i>e </i> <i>n </i>表示这个学期内的时间段的数量; <i>m </i>表示牛牛最多 可以申请更换多少节课程的教室; <i>v </i>表示牛牛学校里教室的数量; <i>e </i>表示牛牛的学校 里道路的数量。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 第二行 <i>n </i>个正整数,第 <i>i</i>  1 ≤ <i>i </i>≤ <i>n </i>)个正整数表示 <i>c<sub>i</sub></i> ,即第 <i>i</i> 个时间段牛牛被安 排上课的教室;保证 1 ≤ <i>c<sub>i</sub> </i>≤ <i>v </i><span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 第三行 <i>n </i>个正整数,第 <i>i </i> 1 ≤ <i>i </i>≤ <i>n </i>)个正整数表示 <i>d<sub>i</sub></i> ,即第 <i>i </i>个时间段另一间上同样课程的教室;保证 1 ≤ <i>d<sub>i</sub> </i>≤ <i>v </i><span></span> </p> </div> <br /> <p class="MsoBodyText" style="margin-left:0cm;"> 第四行 <i>n </i>个实数,第 <i>i </i> 1 ≤ <i>i </i>≤ <i>n </i>)个实数表示 <i>k<sub>i</sub> </i>,即牛牛申请在第 <i>i </i>个时间段更 换教室获得通过的概率。保证 0 ≤ <i>k<sub>i</sub> </i>≤ 1 <span></span> </p> <p class="MsoNormal"> 接下来 <i>e </i>行,每行三个正整数 <i>a<sub>j</sub></i><i> </i> <i>b<sub>j</sub></i><i> </i> <i>w<sub>j</sub></i><i> </i>,表示有一条双向道路连接教室 <i>a<sub>j</sub></i><i> </i>, <i>b<sub>j</sub></i><i> </i>,通过这条道路需要耗费的体力值是 <i>w<sub>j</sub></i> ;保证 1 ≤ <i>a<sub>j</sub></i>, <i>b<sub>j</sub></i><i> </i>≤ <i>v </i> 1 ≤ <i>w<sub>j</sub></i><i> </i>≤ 100 <span></span> </p> <p class="MsoNormal"> 保证 1 ≤ <i>n </i>≤ 2000  0 ≤ <i>m </i>≤ 2000  1 ≤ <i>v </i>≤ 300  0 ≤ <i>e </i>≤ 90000  </p> <p class="MsoNormal"> 保证通过学校里的道路,从任何一间教室出发,都能到达其他所有的教室。 </p> <p class="MsoNormal"> 保证 输入的实数最多包含 3 位小数。 </p>

<p class="MsoNormal" style="margin-left:0cm;"> 输出到文件 <b><i>classroom.out</i></b><b><i> </i></b>中。<span></span> </p> <p class="MsoNormal" style="margin-left:0cm;"> 输出一行,包含一个实数,四舍五入精确到小数点后<u>恰好 </u><u>2</u><u> </u><u></u>,表示答案。你的输出必须和标准输出<u>完全一样</u>才算正确。<span></span> </p> <p class="MsoNormal" style="margin-left:0cm;"> 测试数据保证四舍五入后的答案和准确答案的差的绝对值不大于 4×10-3 。(如果你不知道什么是浮点误差,这段话可以理解为:对于大多数的算法,你可以正常地使用浮点数类型而不用对它进行特殊的处理) </p>

【样例 1 输入】 3 2 3 3 2 1 2 1 2 1 0.8 0.2 0.5 1 2 5 1 3 3 2 3 1

【样例 1 输出】 2.80

0

<div class="WordSection1"> <p class="41" style="margin-left:0cm;"> 【样例<span> 1 </span>说明】<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 所有可行的申请方案和期望收益如下表: </p> </div> <p> <table class="TableNormal" border="1" cellspacing="0" cellpadding="0" width="756" style="border:none;"> <tbody> <tr> <td width="137" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;">申请更换教室的时间段<span></span></span> </p> </td> <td width="137" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;">申请通</span><span style="font-size:12.0pt;font-family:宋体;">过的时间段</span> </p> </td> <td width="137" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;">出现的概率</span> </p> </td> <td width="137" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;">耗费的体力值</span> </p> </td> <td width="137" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;">耗费的体力值的期望</span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:6.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:0cm;text-align:center;"> <span style="font-size:12.0pt;font-family:"">1.0</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">8</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:5.95pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">8.0</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" rowspan="2" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph"> <span style="font-size:8.5pt;font-family:宋体;"> </span> </p> <p class="TableParagraph" align="center" style="text-align:center;"> <span style="font-size:12.0pt;font-family:"">1</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">1</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.8</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:0cm;text-align:center;"> <span style="font-size:12.0pt;font-family:"">4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" rowspan="2" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph"> <span style="font-size:8.5pt;font-family:宋体;"> </span> </p> <p class="TableParagraph" align="center" style="margin-left:5.55pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">4.8</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:6.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.2</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">8</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" rowspan="2" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph"> <span style="font-size:8.5pt;font-family:宋体;"> </span> </p> <p class="TableParagraph" align="center" style="text-align:center;"> <span style="font-size:12.0pt;font-family:"">2</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">2</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.2</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" rowspan="2" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph"> <span style="font-size:8.5pt;font-family:宋体;"> </span> </p> <p class="TableParagraph" align="center" style="margin-left:5.95pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">6.4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:6.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.8</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">8</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" rowspan="2" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph"> <span style="font-size:8.5pt;font-family:宋体;"> </span> </p> <p class="TableParagraph" align="center" style="text-align:center;"> <span style="font-size:12.0pt;font-family:"">3</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">3</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.5</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:0cm;text-align:center;"> <span style="font-size:12.0pt;font-family:"">4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" rowspan="2" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph"> <span style="font-size:8.5pt;font-family:宋体;"> </span> </p> <p class="TableParagraph" align="center" style="margin-left:5.95pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">6.0</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:6.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.5</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">8</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" rowspan="4" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> <p class="TableParagraph" style="margin-left:27.75pt;"> <span style="font-size:12.0pt;font-family:"">1</span><span style="font-size:12.0pt;font-family:宋体;"></span><span style="font-size:12.0pt;font-family:"">2</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="text-align:center;"> <span style="font-size:12.0pt;font-family:"">1</span><span style="font-size:12.0pt;font-family:宋体;"></span><span style="font-size:12.0pt;font-family:"">2</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.16</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:0cm;text-align:center;"> <span style="font-size:12.0pt;font-family:"">4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" rowspan="4" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> <p class="TableParagraph"> <span style="font-family:宋体;"> </span> </p> <p class="TableParagraph" align="center" style="margin-left:5.55pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">4.48</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">1</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.64</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:0cm;text-align:center;"> <span style="font-size:12.0pt;font-family:"">4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">2</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.04</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:6.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.16</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">8</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" rowspan="4" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> <p class="TableParagraph" style="margin-left:27.75pt;"> <span style="font-size:12.0pt;font-family:"">1</span><span style="font-size:12.0pt;font-family:宋体;"></span><span style="font-size:12.0pt;font-family:"">3</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="text-align:center;"> <span style="font-size:12.0pt;font-family:"">1</span><span style="font-size:12.0pt;font-family:宋体;"></span><span style="font-size:12.0pt;font-family:"">3</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" rowspan="4" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> <p class="TableParagraph"> <span style="font-family:宋体;"> </span> </p> <p class="TableParagraph" align="center" style="margin-left:5.95pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">2.8</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">1</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:0cm;text-align:center;"> <span style="font-size:12.0pt;font-family:"">4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">3</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.9pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.1</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:0cm;text-align:center;"> <span style="font-size:12.0pt;font-family:"">4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:6.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.9pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.1</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">8</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" rowspan="4" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> <p class="TableParagraph" style="margin-left:28.2pt;"> <span style="font-size:12.0pt;font-family:"">2</span><span style="font-size:12.0pt;font-family:宋体;"></span><span style="font-size:12.0pt;font-family:"">3</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">2</span><span style="font-size:12.0pt;font-family:宋体;"></span><span style="font-size:12.0pt;font-family:"">3</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.9pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.1</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:0cm;text-align:center;"> <span style="font-size:12.0pt;font-family:"">4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" rowspan="4" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> <p class="TableParagraph"> <span style="font-family:宋体;"> </span> </p> <p class="TableParagraph" align="center" style="margin-left:5.95pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">5.2</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">2</span><span style="font-size:12.0pt;font-family:""></span> </p> <p class="TableParagraph" align="center" style="margin-left:.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:""><br /> </span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.9pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.1</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">3</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:0cm;text-align:center;"> <span style="font-size:12.0pt;font-family:"">4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> <tr> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:6.1pt;text-align:center;"> <span style="font-size:12.0pt;font-family:宋体;"> </span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">0.4</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> <td width="137" valign="top" style="border:solid windowtext 1.0pt;"> <p class="TableParagraph" align="center" style="margin-left:.05pt;text-align:center;"> <span style="font-size:12.0pt;font-family:"">8</span><span style="font-size:12.0pt;font-family:""></span> </p> </td> </tr> </tbody> </table> </p> <p> <p class="41" style="margin-left:0cm;"> 【提示】<span></span> </p> <p class="41" style="margin-left:0cm;"> 1. 道路中可能会有<u>多条</u>双向道路连接相同的两间教室。也有可能有道路两端连接的是<u>同一间</u>教室。 </p> <p class="MsoBodyText" style="margin-left:0cm;"> 2. 请注意区分 <i>n</i>, <i>m</i>, <i>v</i>, <i>e </i>的意义, <i>n </i><u>不是</u>教室的数量, <i>m </i><u>不是</u>道路的数量。 </p> </p>

NOIP2016DAY1(三)

2017-07-20 19:24:34

1

512

N

0

0

0

1863

组合数问题(problem)

<img alt="" src="/JudgeOnline/upload/image/20170720/20170720192657_69728.png" />

<p class="MsoNormal"> 从文件 <b><i>problem.in</i></b><b><i> </i></b>中读入数据。 </p> <p class="MsoNormal" style="margin-left:0cm;"> 第一行有两个整数 <i>t</i>, <i>k </i>,其中 <i>t </i>代表该测试点总共有多少组测试数据,<i>k </i>的意义见【问题描述】。<span></span> </p> <p class="MsoNormal"> 接下来 <i>t </i>行每行两个整数 <i>n</i>, <i>m </i>,其中 <i>n</i>, <i>m </i>的意义见【问题描述】。<span></span> </p>

<p class="MsoNormal"> 输出到文件 <b><i>problem.out</i></b><b><i> </i></b>中。<span></span> </p> <p class="MsoNormal"> <i>t</i>行,每行一个整数代表所有的 0 ≤ <i>i </i>≤ <i>n</i>, 0 ≤<i>j </i>≤ min (<i>i</i>, <i>m</i>) 中有多少对 (<i>i</i>, <i>j</i>) 满足C(i,j)k的倍数。 </p>

【样例 1 输入】 1 2 3 3 【样例 2 输入】 2 5 4 5 6 7

【样例 1 输出】 1 【样例 2 输出】 0 7

0

<div class="WordSection1"> <p class="41" style="margin-left:0cm;"> 【样例<span> 1 </span>说明】<span></span> </p> <p class="41" style="margin-left:0cm;"> 在所有可能的情况中,只有C(2,1)=22的倍数。<span></span> </p> </div> <p> 【数据范围】 </p> <p> n,m<=2000k<=21t<=10<sup>4</sup> </p>

NOIP2016DAY2(一)

2018-01-10 20:43:01

1

512

N

15

47

0

1864

蚯蚓(earthworm)

<p class="MsoBodyText" style="margin-left:0cm;"> 本题中,我们将用符号 L<i>c</i>J 表示对 <i>c </i>向下取整,例如: L3.0J = L3.1J = L3.9J = 3 </p> <p class="MsoBodyText" style="margin-left:0cm;"> 蛐蛐国最近蚯蚓成灾了!隔壁跳蚤国的跳蚤也拿蚯蚓们没办法,蛐蛐国王只好去请神刀手来帮他们消灭蚯蚓。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 蛐蛐国里现在共有 <i>n </i>只蚯蚓( <i>n </i>为正整数)。每只蚯蚓拥有长度,我们设第 <i>i </i>只蚯蚓的长度为 <i>a</i><i>i </i>( <i>i </i>= 1, 2, . . . , <i>n </i>),并保证所有的长度都是<u>非负</u>整数(即:可能存在长度为0的蚯蚓)。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 每一秒,神刀手会在所有的蚯蚓中,准确地找到最长的那一只(如有多个则任选一个)将其切成两半。神刀手切开蚯蚓的位置由常数 <i>p </i>(是满足 0 < <i>p </i>< 1 的有理数)决定,设这只蚯蚓长度为 <i>x </i>,神刀手会将其切成两只长度分别为 L<i>px</i>J  <i>x </i> L<i>px</i>J 的蚯蚓。特殊地,如果这两个数的其中一个等于 0 ,则这个长度为 0 的蚯蚓也会被保留。此 外,除了刚刚产生的两只新蚯蚓,其余蚯蚓的长度都会增加 <i>q</i>(是一个非负整常数)。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 蛐蛐国王知道这样不是长久之计,因为蚯蚓不仅会越来越多,还会越来越长。蛐 蛐国王决定求助于一位有着洪荒之力的神秘人物,但是救兵还需要 <i>m </i>秒才能到来......<i>m </i>为非负整数)蛐蛐国王希望知道这 <i>m </i>秒内的战况。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 具体来说,他希望知道:<span></span> </p> <p class="MsoBodyText" style="margin-left:21.0pt;text-indent:-21.0pt;"> l  <i>m </i>秒内,每一秒被切断的蚯蚓被切断前的长度(有 <i>m </i>个数);<span></span> </p> <p class="MsoBodyText" style="margin-left:21.0pt;text-indent:-21.0pt;"> l  <i>m </i>秒后,所有蚯蚓的长度(有 <i>n </i>+ <i>m </i>个数)。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 蛐蛐国王当然知道怎么做啦<span>! </span>但是他想考考你...... </p>

<p class="MsoNormal"> 从文件 <b><i>earthworm.in</i></b><b><i> </i></b>中读入数据。 </p> <p class="MsoNormal" style="margin-left:0cm;"> 第一行包含六个整数 <i>n</i>, <i>m</i>, <i>q</i>, <i>u</i>, <i>v</i>, <i>t </i>,其中: <i>n</i>, <i>m</i>, <i>q </i>的意义见【问题描述】; <i>u</i>, <i>v</i>, <i>t </i>均 为正整数;你需要自己计算 <i>p </i>= <i>u</i>/<i>v </i>(保证 0 < <i>u </i>< <i>v </i>);<i>t </i>是输出参数,其含义将会在【输出格式】中解释。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 第二行包含 <i>n </i>个非负整数,为 <i>a</i><sub>1</sub>, <i>a</i><sub>2</sub>, . . . , <i>a<sub>n</sub> </i>,即初始时 <i>n </i>只蚯蚓的长度。 </p> <p class="MsoBodyText" style="margin-left:0cm;"> 同一行中相邻的两个数之间,恰好用一个空格隔开。<span></span> </p> <p class="MsoNormal"> 保证 1 ≤ <i>n </i>≤ 10<sup>5</sup>  0 ≤ <i>m </i>≤ 7 × 10<sup>6</sup>  0 < <i>u </i>< <i>v </i>≤ 10<sup>9</sup>  0 ≤ <i>q </i>≤ 200  1 ≤ <i>t </i>≤ 71 <span></span> </p> <p class="MsoNormal"> 0 ≤ <i>ai </i>≤ 10<sup>8</sup> <span></span> </p>

<p class="MsoNormal"> 输出到文件 <b><i>earthworm.out</i></b> </p> 第一行输出[m/t]个整数,按时间顺序,依次输出第 <i>t</i>秒,第 2<i>t</i><i> </i>秒,第 3<i>t</i><i> </i>秒,......被切 断蚯蚓(在被切断前)的长度。第二行输出[(m+n)/t]个整数,输出 <i>m </i>秒后蚯蚓的长度:需要按从大到小的顺序,依次输出排名第 <i>t </i>,第 2<i>t </i>,第 3<i>t </i>. . . . . . 的长度。 <p class="MsoBodyText" style="margin-left:0cm;"> <span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 同一行中相邻的两个数之间,恰好用一个空格隔开。即使某一行没有任何数需要输出,你也应输出一个空行。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 请阅读样例来更好地理解这个格式。<span></span> </p>

【样例 1 输入】 3 7 1 1 3 1 3 3 2 【样例 2 输入】 3 7 1 1 3 2 3 3 2 【样例 3 输入】 3 7 1 1 3 9 3 3 2

【样例 1 输出】 3 4 4 4 5 5 6 6 6 6 5 5 4 4 3 2 2 【样例 2 输出】 4 4 5 6 5 4 3 2 【样例 3 输出】 2

0

<p class="41" style="margin-left:0cm;"> 【样例<span> 1 </span>说明】<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 在神刀手到来前:3 只蚯蚓的长度为 3,3,2<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 1 秒后:一只长度为 3 的蚯蚓被切成了两只长度分别为 1  2 的蚯蚓,其余蚯蚓的长度增加了 1。最终 4 只蚯蚓的长度分别为(1,2),4,3。括号表示这个位置刚刚有一只蚯蚓被切断。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 2 秒后:一只长度为 4 的蚯蚓被切成了 1  35 只蚯蚓的长度分别为:2,3,(1,3),4<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 3 秒后:一只长度为 4 的蚯蚓被切断。6 只蚯蚓的长度分别为:3,4,2,4,(1,3)<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 4 秒后:一只长度为 4 的蚯蚓被切断。7 只蚯蚓的长度分别为:4,(1,3),3,5,2,4<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 5 秒后:一只长度为 5 的蚯蚓被切断。8 只蚯蚓的长度分别为:5,2,4,4,(1,4),3,5<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 6 秒后:一只长度为 5 的蚯蚓被切断。9 只蚯蚓的长度分别为:(1,4),3,5,5,2,5,4,6<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 7 秒后:一只长度为 6 的蚯蚓被切断。10 只蚯蚓的长度分别为:2,5,4,6,6,3,6,5,(2,4)<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 所以,7 秒内被切断的蚯蚓的长度依次为 3,4,4,4,5,5,67 秒后,所有蚯蚓长度从大到小排序为 6,6,6,5,5,4,4,3,2,2<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> <p class="41" style="margin-left:0cm;"> 【样例<span> 2 </span>说明】<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 这个数据中只有 <i>t </i>= 2 与上个数据不同。只需在每行都改为每两个数输出一个数即可。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 虽然第一行最后有一个 6 没有被输出,但是第二行仍然要重新从第二个数再开始输出。 </p> <p class="41" style="margin-left:0cm;"> 【样例<span> 3 </span>说明】<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 这个数据中只有 <i>t </i>= 9 与上个数据不同。注意第一行没有数要输出,但也要输出一个空行。<span></span> </p> </p>

NOIP2016DAY2(二)

2017-07-20 19:33:07

1

512

N

0

0

0

1865

愤怒的小鸟(angrybirds)

<p class="MsoBodyText" style="margin-left:0cm;"> Kiana 最近沉迷于一款神奇的游戏无法自拔。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 简单来说,这款游戏是在一个平面上进行的。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 有一架弹弓位于 (0, 0) 处,每次 Kiana 可以用它向第一象限发射一只红色的小鸟,小鸟们的飞行轨迹均为形如 y = ax<sup>2</sup> + bx 的曲线,其中 a, b  Kiana 指定的参数,且必须满足 a < 0<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 当小鸟落回地面(即 x 轴)时,它就会瞬间消失。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 在游戏的某个关卡里,平面的第一象限中有 n 只绿色的小猪,其中第 i 只小猪所在的坐标为 (xi, yi)<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 如果某只小鸟的飞行轨迹经过了 (xi, yi) ,那么第 i 只小猪就会被消灭掉,同时小鸟将会沿着原先的轨迹继续飞行;<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 如果一只小鸟的飞行轨迹没有经过 (xi, yi) ,那么这只小鸟飞行的全过程就不会对第 i 只小猪产生任何影响。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 例如,若两只小猪分别位于 (1, 3)  (3, 3) Kiana 可以选择发射一只飞行轨迹为 y = </p> <p class="MsoBodyText" style="margin-left:0cm;"> x<sup>2</sup> + 4x 的小鸟,这样两只小猪就会被这只小鸟一起消灭。 </p> <p class="MsoBodyText" style="margin-left:0cm;"> 而这个游戏的目的,就是通过发射小鸟消灭所有的小猪。 </p> <p class="MsoBodyText" style="margin-left:0cm;"> 这款神奇游戏的每个关卡对 Kiana 来说都很难,所以 Kiana 还输入了一些神秘的指令,使得自己能更轻松地完成这个游戏。这些指令将在【输入格式】中详述。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 假设这款游戏一共有 T 个关卡,现在 Kiana 想知道,对于每一个关卡,至少需要发射多少只小鸟才能消灭所有的小猪。由于她不会算,所以希望由你告诉她。<span></span> </p>

<div class="WordSection1"> <p class="MsoNormal" style="margin-left:0cm;"> 从文件 <b><i>angrybirds.in</i></b><b><i> </i></b>中读入数据。 </p> <p class="MsoNormal" style="margin-left:0cm;"> 第一行包含一个正整数 <i>T </i>,表示游戏的关卡总数。 </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 下面依次输入这 <i>T </i>个关卡的信息。每个关卡第一行包含两个非负整数 <i>n</i>, <i>m </i>,分别表示该关卡中的小猪数量和 Kiana 输入的神秘指令类型。接下来的 <i>n </i>行中,第 <i>i </i>行包含两个正实数 <i>x<sub>i</sub></i>, <i>y<sub>i</sub> </i>,表示第 <i>i </i>只小猪坐标为 (<i>x<sub>i</sub></i>, <i>y<sub>i</sub></i>) 。数据保证同一个关卡中不存在两只坐标完全相同的小猪。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 如果<i>m</i> = 0 ,表示 Kiana 输入了一个没有任何作用的指令。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 如果<i>m</i> = 1 ,则这个关卡将会满足:至多用「<i>n</i>/3 + 1¬只小鸟即可消灭所有小猪。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 如果<i>m</i> = 2 ,则这个关卡将会满足:一定存在一种最优解,其中有一只小鸟消灭了至少L<i>n</i>/3J 只小猪。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;"> 保证 1 ≤ <i>n </i>≤ 18  0 ≤ <i>m </i>≤ 2  0 < <i>x<sub>i</sub></i>, <i>y<sub>i</sub> </i>< 10 ,输入中的实数均保留到小数点后两 位。<span></span> </p> </div> <p class="MsoBodyText" style="margin-left:0cm;"> 上文中,符号 「<i>c</i>¬  L<i>c</i>J 分别表示对 <i>c </i>向上取整和向下取整,例如: 「2.1¬ = 2.9¬ =3.0¬ = L3.0J = L3.1J = L3.9J = 3  </p>

<p class="MsoBodyText" style="margin-left:0cm;"> 输出到文件<b><i> angrybirds.out </i></b>中。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 对每个关卡依次输出一行答案。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 输出的每一行包含一个正整数,表示相应的关卡中,消灭所有小猪最少需要的小鸟数量。<span></span> </p>

【样例 1 输入】 2 2 0 1.00 3.00 3.00 3.00 5 2 1.00 5.00 2.00 8.00 3.00 9.00 4.00 8.00 5.00 5.00 【样例 2 输入】 3 2 0 1.41 2.00 1.73 3.00 3 0 1.11 1.41 2.34 1.79 2.98 1.49 5 0 2.72 2.72 2.72 3.14 3.14 2.72 3.14 3.14 5.00 5.00 【样例 3 输入】 1 10 0 7.16 6.28 2.02 0.38 8.33 7.78 7.68 2.09 7.46 7.86 5.77 7.44 8.24 6.72 4.42 5.11 5.42 7.79 8.15 4.99

【样例 1 输出】 1 1 【样例 2 输出】 2 2 3 【样例 3 输出】 6

0

<div class="WordSection1"> <p class="41" style="margin-left:0cm;"> 【样例<span> 1 </span>说明】<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 这组数据中一共有两个关卡。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 第一个关卡与【问题描述】中的情形相同,2只小猪分别位于(1.00,3.00)(3.00,3.00),只需发射一只飞行轨迹为y = x<sup>2</sup> + 4x的小鸟即可消灭它们。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;"> 第二个关卡中有 5 只小猪,但经过观察我们可以发现它们的坐标都在抛物线y = x<sup>2</sup> + 6x上,故 Kiana 只需要发射一只小鸟即可消灭所有小猪。<span></span> </p> </div> <br />

NOIP2016DAY2(三)

2017-07-20 19:35:55

2

512

N

0

0

0

1866

神奇的幻方

<p align="left" class="MsoNormal" style="text-indent:24pt;"> 幻方是一种很神奇的<span> N*N </span>矩阵:它由数字 1,2,3, … … , N*N 构成,且每行、每列及两条对角线上的数字之和都相同。 </p> <p align="left" class="MsoNormal" style="text-indent:24pt;"> <span>N</span>为奇数时,我们可以通过以下方法构建一个幻方: <span></span> </p> <p align="left" class="MsoNormal" style="text-indent:24pt;"> 首先将 1 写在第一行的中间。 </p> <p align="left" class="MsoNormal" style="text-indent:24pt;"> 之后,按如下方式从小到大依次填写每个数<span>K</span>(K= 2,3, … , N*N ) </p> <p class="MsoNormal" style="text-indent:-18pt;margin-left:46pt;"> 1.   (K1) 在第一行但不在最后一列,则将<span>K</span>填在最后一行,(K 1) 所在列的右一列; </p> <p class="MsoNormal" style="text-indent:-18pt;margin-left:46pt;"> 2.   (K 1) 在最后一列但不在第一行,则将<span>K</span>填在第一列,(K 1) 所在行的上一行; </p> <p align="left" class="MsoNormal" style="text-indent:-18pt;margin-left:46pt;"> 3.   (K 1) 在第一行最后一列,则将<span>K</span>填在 (K 1) 的正下方; </p> <p class="MsoNormal" style="text-indent:-18pt;margin-left:46pt;"> 4.   (K 1) 既不在第一行,也不在最后一列,如果 (K 1) 的右上方还未填数, 则将K填在(K 1)的右上方,否则将<span>K</span>填在 (K 1) 的正下方 </p> <p class="MsoNormal" style="margin-left:28pt;"> 现给定<span>N</span>,请按上述方法构造<span> N*N </span>的幻方。 </p>

<p align="left" class="MsoNormal" style="margin-left:27pt;"> 输入文件名为 magic.in </p> <p align="left" class="MsoNormal" style="margin-left:27pt;"> 输入文件只有一行,包含一个整数<span>N</span>,即幻方的大小。 </p>

<p align="left" class="MsoNormal" style="margin-left:27pt;"> 输出文件名为 magic.out </p> <p align="left" class="MsoNormal" style="text-indent:21pt;"> 输出文件包含<span>N</span>行,每行<span>N</span>个整数,即按上述方法构造出的<span>N*N</span>的幻方。相邻 两个整数之间用单个空格隔开。 </p>

3

8 1 6 3 5 7 4 9 2

0

<p align="left" class="MsoNormal" style="margin-left:27pt;"> 对于 100% 的数据,1 ≤N≤39 <span>N</span>为奇数。 </p>

NOIP2015DAY2(一)

2017-12-30 10:22:44

1

128

N

16

36

0

1867

信息传递

<p class="MsoNormal" align="left" style="text-indent:24pt;">  <i><span>n</span></i><span> </span>个同学(编号为 1  <i><span>n</span></i>)正在玩一个信息传递的游戏。在游戏里每人都有一个固定的信息传递对象,其中,编号为 <i><span>i</span></i><span> </span>的同学的信息传递对象是编号为 <i><span>Ti</span></i><span> </span>的同学。 游戏开始时,每人都只知道自己的生日。之后每一轮中,所有人会同时将自己当前所知的生日信息告诉各自的信息传递对象(注意:可能有人可以从若干人那里获取信息,但是每人只会把信息告诉一个人,即自己的信息传递对象)。当有人从别人口中得知自己的生日时,游戏结束。请问该游戏一共可以进行几轮? </p>

<p class="MsoNormal" align="left" style="text-indent:24pt;"> 输入文件名为 message.in<b></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 输入共 2 行。<span></span> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;">  1 行包含 1 个正整数 <i>n </i>,表示 <i><span>n</span></i><span> </span>个人。<span></span> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;">  2 行包含 <i><span>n</span></i><span> </span>个用空格隔开的正整数<i><span>T1,T2,</span></i><i>… ,</i><i>Tn</i>,其中第<i><span>Ti</span></i>个整数表示编号为 <i>i </i>的同学的信息传递对象是编号为 <i>Ti</i> 的同学,<i>Ti</i> ≤<i>n</i> <i><span>Ti</span></i><span> </span>≠<i>i</i><span></span> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 数据保证游戏一定会结束。<span></span> </p>

<p class="MsoNormal" align="left" style="text-indent:23.5pt;"> 输出文件名为 message.out<b><span></span></b> </p> <p class="MsoNormal" align="left" style="text-indent:23.5pt;"> 输出共 1 行,包含 1 个整数,表示游戏一共可以进行多少轮。 <span></span> </p>

5 2 4 2 3 1

3

0

<p class="MsoNormal" align="left"> <b>【输入输出样例 </b><b>1</b><b> </b><b>说明】</b><b></b> </p> <p class="MsoNormal" align="left"> <b><img src="/JudgeOnline/upload/image/20170728/20170728210007_24774.jpg" alt="" /><br /> </b> </p> <p class="MsoNormal" align="left"> <b> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 游戏的流程如图所示。当进行完第 3 轮游戏后,4 号玩家会听到 2 号玩家告诉他自己的生日,所以答案为 3。当然,第 3 轮游戏后,2 号玩家、3 号玩家都能从自己的消息 来源得知自己的生日,同样符合游戏结束的条件。 </p> <div class="WordSection1"> <p class="MsoNormal" align="left"> <b>【数据规模与约定】</b><b></b> </p> <p class="MsoNormal" style="text-indent:24.0pt;"> 对于<span> 30%</span>的数据 <i><span>n</span></i><span> ≤200</span> <span></span> </p> <p class="MsoNormal" style="text-indent:24.0pt;"> 对于<span> 60%</span>的数据,<i><span>n </span></i><span>≤ 2500</span> <span></span> </p> <p class="MsoNormal" style="text-indent:24.0pt;"> 对于<span> 100%</span>的数据,<i><span>n </span></i><span>≤ 200000</span><span></span> </p> </div> <br /> <br /> </b> </p>

NOIP2015DAY1(二)

2017-07-28 21:00:39

1

128

N

1

1

0

1868

斗地主

<p class="MsoNormal" align="left" style="text-indent:24pt;"> 牛牛最近迷上了一种叫斗地主的扑克游戏。斗地主是一种使用黑桃、红心、梅花、 方片的 A  K 加上大小王的共 54 张牌来进行的扑克牌游戏。在斗地主中,牌的大小关系根据<b><i><u>牌的数码</u></i></b>表示如下:3<4<5<6<7<8<9<10<J<Q<K<A<2<小王<大王,而<b>花色并不对牌的大小产生影响</b>。每一局游戏中,一副<b><i><u>手牌</u></i></b> n 张牌组成。游戏者每次可以根据规定的<b><i><u>牌型</u></i></b>进行出牌,首先打光自己的手牌一方取得游戏的胜利。 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 现在,牛牛只想知道,对于自己的若干组<b><i><u>手牌</u></i></b>,分别最少需要多少次出牌可以将它们打光。请你帮他解决这个问题。 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 需要注意的是,本题中游戏者每次可以出手的<b><i><u>牌型</u></i></b>与一般的斗地主相似而略有不同。具体规则如下:<span></span> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> <img src="/JudgeOnline/upload/image/20170728/20170728210255_79445.png" alt="" /> </p>

<p class="MsoNormal" align="left" style="text-indent:24pt;"> 输入文件名为 landlords.in<span></span> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 第一行包含用空格隔开的2个正整数<span>T</span>,n,表示手牌的组数以及每组手牌的张数。<span></span> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 接下来<span>T</span>组数据,每组数据<span>n</span>行,每行一个非负整数对<span>ai</span>,bi,表示一张牌,其中<span>ai</span>表示牌的数码,<span>bi</span>表示牌的花色,中间用空格隔开。特别的,我们用 1 来表示数码 A11 表示数码 J12 表示数码 Q13 表示数码 K;黑桃、红心、梅花、方片分别用 1-4 来表示;小王的表示方法为 0 1,大王的表示方法为 0 2<span></span> </p>

<p class="MsoNormal" align="left" style="text-indent:24pt;"> 输出文件名为 landlords.out </p> <p class="MsoNormal" align="left" style="text-indent:24pt;">  T 行,每行一个整数,表示打光第<span>i</span>组手牌的最少次数。 <span></span> </p>

【输入输出样例 1 1 8 7 4 8 4 9 1 10 4 11 1 5 1 1 4 1 1 【输入输出样例 2 1 17 12 3 4 3 2 3 5 4 10 2 3 3 12 2 0 1 1 3 10 1 6 2 12 1 11 3 5 2 12 4 2 2 7 2

【输入输出样例 1 3 【输入输出样例 2 6

0

<p class="MsoNormal" align="left"> <b>【输入输出样例 </b><b>1</b><b> </b><b>说明】</b><b></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 共有 1 组手牌,包含 8 张牌:方片7,方片8,黑桃9,方片10,黑桃J,黑桃5,方片A 以及黑桃A。可以通过打单顺子(方片7,方片8,黑桃9,方片10,黑桃J),单张牌(黑桃5)以及对子牌(黑桃A 以及方片A)在3次内打光。 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> <p class="MsoNormal" align="left" style="text-indent:-21pt;"> <b>【数据规模与约定】<span></span></b> </p> <p class="MsoNormal" style="text-indent:24.0pt;"> 对于不同的测试点,我们约定手牌组数T与张数n的规模如下: </p> <img src="/JudgeOnline/upload/image/20170728/20170728210901_76240.png" alt="" /> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> <p class="MsoNormal" align="left" style="margin-left:21pt;"> 数据保证:所有的手牌都是随机生成的。<span></span> </p> </p>

NOIP2015DAY1(三)

2017-07-28 21:09:06

2

1024

N

0

0

0

1869

跳石头

<p class="MsoNormal" style="text-indent:24.0pt;"> 一年一度的<span>“</span>跳石头<span>”</span>比赛又要开始了!<b><span></span></b> </p> <p class="MsoNormal" style="text-indent:24.0pt;"> 这项比赛将在一条笔直的河道中进行,河道中分布着一些巨大岩石。组委会已经选择好了两块岩石作为比赛起点和终点。在起点和终点之间,有 N 块岩石(不含起点和终点的岩石)。在比赛过程中,选手们将从起点出发,每一步跳向相邻的岩石,直至到达终点。 </p> <p class="MsoNormal" style="text-indent:24.0pt;"> 为了提高比赛难度,组委会计划移走一些岩石,使得选手们在比赛过程中的最短跳跃距离尽可能长。由于预算限制,组委会至多从起点和终点之间移走 M 块岩石(不能移走起点和终点的岩石)。 </p>

<p class="MsoNormal" style="text-indent:24.0pt;"> 输入文件名为<span> stone.in</span><span></span> </p> <p class="MsoNormal" style="text-indent:24.0pt;"> 输入文件第一行包含三个整数 LNM,分别表示起点到终点的距离,起点和终点之间的岩石数,以及组委会至多移走的岩石数。 </p> <p class="MsoNormal" style="text-indent:24.0pt;"> 接下来 N 行,每行一个整数,第 i 行的整数 Di0 < Di < L)表示第 i 块岩石与 起点的距离。这些岩石按与起点距离从小到大的顺序给出,且不会有两个岩石出现在同一个位置。<span></span> </p>

<p class="MsoNormal" style="text-indent:24.0pt;"> 输出文件名为 stone.out </p> <p class="MsoNormal" style="text-indent:24.0pt;"> 输出文件只包含一个整数,即最短跳跃距离的最大值。<span></span> </p>

25 5 2 2 11 14 17 21

4

0

<p class="MsoNormal" align="left"> <b>【输入输出样例 </b><b>1</b><b> </b><b>说明】</b><b></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 将与起点距离为 2  14 的两个岩石移走后,最短的跳跃距离为 4(从与起点距离 17 的岩石跳到距离 21 的岩石,或者从距离 21 的岩石跳到终点)。 </p> <h4 style="text-indent:24pt;"> <b><span style="font-size:16px;">【数据规模与约定】<br /> </span></b><span style="font-size:16px;">对于 20%的数据,0 ≤ M ≤ N ≤ 10<br /> </span><span style="font-size:16px;">对于 50%的数据,0 ≤ M ≤ N ≤ 100<br /> </span><span style="font-size:16px;">对于 100%的数据,0 ≤ M ≤ N ≤ 50,0001 ≤ L ≤ 1,000,000,000</span> </h4> <p class="MsoNormal" align="left"> <b></b> </p> <p> <br /> </p>

NOIP2015DAY2(一)

2017-07-28 21:22:30

1

128

N

8

11

0

1870

子串

<p class="MsoNormal" style="text-indent:24.0pt;"> 有两个仅包含小写英文字母的字符串AB。现在要从字符串A中取出k<b><i><u>互不重叠</u></i></b>的非空子串,然后把这<i> </i>k<i> </i>个子串按照其在字符串<i> </i>A<i> </i>中出现的顺序依次连接起来得到一个新的字符串,请问有多少种方案可以使得这个新串与字符串 B 相等?注意:子串取出的位置不同也认为是不同的方案。<span></span> </p>

<p class="MsoNormal" align="left" style="text-indent:24pt;"> 输入文件名为 substring.in </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 第一行是三个正整数 nmk,分别表示字符串 A 的长度,字符串 B 的长度,以及问题描述中所提到的 k,每两个整数之间用一个空格隔开。 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 第二行包含一个长度为 n 的字符串,表示字符串A </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 第三行包含一个长度为 m 的字符串,表示字符串B </p>

<p class="MsoNormal" align="left" style="text-indent:24pt;"> 输出文件名为 substring.out </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 输出共一行,包含一个整数,表示所求方案数。<b>由于答案可能很大</b><b></b><b>所以这里要求输出答案对 </b><b>1,000,000,007</b><b> </b><b>取模的结果。</b> </p>

【输入输出样例 1 6 3 1 aabaab aab 【输入输出样例 2 6 3 2 aabaab aab 【输入输出样例 3 6 3 3 aabaab aab

【输入输出样例 1 2 【输入输出样例 2 7 【输入输出样例 3 7

0

<p class="MsoNormal" align="left"> <b>【输入输出样例说明】</b><b> </b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 所有合法方案如下:(加下划线的部分表示取出的子串) <span></span> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 样例 1<b><u>aab</u></b> aab / aab <b><u>aab</u></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 样例 2<b><u>a</u></b><b> <u>ab</u></b> aab / <b><u>a</u></b> aba <b><u>ab</u></b> / a <b><u>a</u></b> ba <b><u>ab</u></b> / aab <b><u>a</u></b><b> <u>ab</u></b> </p> <p class="MsoNormal" align="left" style="text-indent:71.3pt;"> <b><u>aa</u></b><b> <u>b</u> </b>aab /<b> <u>aa</u> </b>baa<b> <u>b</u> </b>/ aab<b> <u>aa</u> <u>b</u></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 样例 3<b><u>a</u></b><b> <u>a</u> <u>b</u></b> aab / <b><u>a</u></b><b> <u>a</u></b> baa <b><u>b</u></b> / <b><u>a</u></b> ab <b><u>a</u></b> a <b><u>b</u></b> / <b><u>a</u></b> aba <b><u>a</u></b><b> <u>b</u></b> </p> <p class="MsoNormal" align="left" style="text-indent:72pt;"> a <b><u>a</u></b> b <b><u>a</u></b> a <b><u>b</u></b> / a <b><u>a</u></b> ba <b><u>a</u> <u>b</u></b> / aab <b><u>a</u> <u>a</u> <u>b</u></b> </p> <p class="MsoNormal" align="left" style="text-indent:72pt;"> <b><u> </u></b> </p> <p class="MsoNormal" align="left"> <b><u><b>【数据规模与约定】</b><b></b> </u></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> <b><u>对于第 1 组数据:1≤n≤5001≤m≤50k=1</u></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> <b><u>对于第 2 组至第 3 组数据:1≤n≤5001≤m≤50k=2 <span></span> </u></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> <b><u>对于第 4 组至第 5 组数据:1≤n≤5001≤m≤50k=m <span></span> </u></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> <b><u>对于第 1 组至第 7 组数据:1≤n≤5001≤m≤501≤k≤m <span></span> </u></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> <b><u>对于第 1 组至第 9 组数据:1≤n≤10001≤m≤1001≤k≤m <span></span> </u></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> <b><u>对于所有 10 组数据:1≤n≤10001≤m≤2001≤k≤m</u></b> </p> <p> <br /> </p>

NOIP2015DAY2(二)

2017-07-28 21:25:06

1

128

N

0

0

0

1871

运输计划

<p class="MsoNormal" align="left" style="text-indent:24pt;"> 公元 2044 年,人类进入了宇宙纪元。 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> L 国有 n 个星球,还有 n-1 <b><i><u>双向</u></i></b>航道,每条航道建立在两个星球之间,这 n-1 条航道<b><i><u>连通</u></i></b> L 国的所有星球。 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;">  P 掌管一家物流公司,该公司有很多个运输计划,每个运输计划形如:有一艘物流飞船需要从 ui 号星球沿<b><i><u>最快</u></i></b>的宇航路径飞行到 vi 号星球去。显然,飞船驶过一条航道是需要时间的,对于航道j,任意飞船驶过它所花费的时间为 tj,并且任意两艘飞船之间<b><i><u>不会</u></i></b>产生任何干扰。 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 为了鼓励科技创新,L 国国王同意小 P 的物流公司参与 L 国的航道建设,即允许小 P 把某一条航道改造成虫洞,飞船驶过虫洞<b><i><u>不消耗</u></i></b>时间。 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 在虫洞的建设完成前小 P 的物流公司就预接了 m 个运输计划。在虫洞建设完成后,这 m 个运输计划会<b><i><u>同时</u></i></b>开始,所有飞船<b><i><u>一起</u></i></b>出发。当这 m 个运输计划<b><i><u>都完成</u></i></b>时,小 P 的 物流公司的阶段性工作就完成了。 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 如果小 P 可以<b><i><u>自由选择</u></i></b>将哪一条航道改造成虫洞,试求出小 P 的物流公司完成阶段性工作所需要的最短时间是多少? </p>

<p class="MsoNormal" align="left" style="text-indent:24pt;"> 输入文件名为 transport.in </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 第一行包括两个正整数 nm,表示 L 国中星球的数量及小 P 公司预接的运输计划的数量,星球从 1  n 编号。 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 接下来 n-1 行描述航道的建设情况,其中第 i 行包含三个整数 ai, bi  ti,表示第 i 条双向航道修建在 ai  bi 两个星球之间,任意飞船驶过它所花费的时间为 ti </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 接下来 m 行描述运输计划的情况,其中第 j 行包含两个正整数 uj  vj,表示第 j 个 运输计划是从 uj 号星球飞往 vj 号星球。 </p>

<p class="MsoNormal" align="left" style="text-indent:24pt;"> 输出文件名为 transport.out </p> <p class="MsoNormal" align="left" style="text-indent:24pt;">  1 行,包含 1 个整数,表示小 P 的物流公司完成阶段性工作所需要的最短时间。 </p>

6 3 1 2 3 1 6 4 3 1 7 4 3 6 3 5 5 3 6 2 5 4 5

11

0

<p class="MsoNormal" align="left"> <b>【输入输出样例 </b><b>1</b><b> </b><b>说明】</b><b></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 将第 1 条航道改造成虫洞:则三个计划耗时分别为:111211,故需要花费的时间为 12 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 将第 2 条航道改造成虫洞:则三个计划耗时分别为:71511,故需要花费的时间为 15 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 将第 3 条航道改造成虫洞:则三个计划耗时分别为:4811,故需要花费的时间为 11 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 将第 4 条航道改造成虫洞:则三个计划耗时分别为:11155,故需要花费的时间为 15 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 将第 5 条航道改造成虫洞:则三个计划耗时分别为:11106,故需要花费的时间为 11 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 故将第 3 条或第 5 条航道改造成虫洞均可使得完成阶段性工作的耗时最短,需要花费的时间为 11 </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> <br /> </p> <p class="MsoNormal" align="left"> <b>【数据规模与约定】</b><b></b> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 所有测试数据的范围和特点如下表所示 </p> <img src="/JudgeOnline/upload/image/20170728/20170728212726_45457.png" alt="" /> <p> <br /> </p> <p class="MsoNormal" align="left" style="text-indent:24pt;"> <p class="MsoNormal" align="left" style="text-indent:24pt;"> 请注意常数因子带来的程序效率上的影响。 </p> </p>

NOIP2015DAY2(三)

2017-07-28 21:27:51

1

256

N

0

0

0

1872

生活大爆炸版石头剪刀布

<p class="MsoNormal" style="text-indent:21.0pt;"> 石头剪刀布是常见的猜拳游戏:石头胜剪刀,剪刀胜布,布胜石头。如果两个人出拳一样,则不分胜负。在《生活大爆炸》第二季第<span>8</span>集中出现了一种石头剪刀布的升级版游戏。升级版游戏在传统的石头剪刀布游戏的基础上,增加了两个新手势:<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 斯波克:《星际迷航》主角之一。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 蜥蜴人:《星际迷航》中的反面角色。 </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 这五种手势的胜负关系如表一所示,表中列出的是甲对乙的游戏结果。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <img src="/JudgeOnline/upload/image/20170728/20170728222947_68127.png" alt="" width="600" height="197" title="" align="" /> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <br /> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 现在,小<span>A</span>和小<span>B</span>尝试玩这种升级版的猜拳游戏。已知他们的出拳都是有周期性规律的,但周期长度不一定相等。例如:如果小<span>A</span>石头<span>-</span><span>-</span>石头<span>-</span>剪刀<span>-</span>蜥蜴人<span>-</span>斯波克长度为<span>6</span>的周期出拳,那么他的出拳序列就是石头<span>-</span><span>-</span>石头<span>-</span>剪刀<span>-</span>蜥蜴人<span>-</span>斯波克<span>-</span>石头<span>-</span><span>-</span>石头<span>-</span>剪刀<span>-</span>蜥蜴人<span>-</span>斯波克<span>-</span>……”,而如果小<span>B</span>剪刀<span>-</span>石头<span>-</span><span>-</span>斯波克<span>-</span>蜥蜴人长度为<span>5</span>的周期出拳,那么他出拳的序列就是剪刀<span>-</span>石头<span>-</span><span>-</span>斯波克<span>-</span>蜥蜴人<span>-</span>剪刀<span>-</span>石头<span>-</span><span>-</span>斯波克<span>-</span>蜥蜴人<span>-……”</span> </p> <p class="MsoNormal" style="text-indent:21.0pt;">   </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 已知小<span>A</span>和小<span>B</span>一共进行<span>N</span>次猜拳。每一次赢的人得<span>1</span>分,输的得<span>0</span>分;平局两人都得<span>0</span>分。现请你统计<span>N</span>次猜拳结束之后两人的得分。<span></span> </p> <p> <br /> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输入文件名为<span>rps.in</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 第一行包含三个整数:<span>N</span><span>NA</span><span>NB</span>,分 别 表 示 共 进 行<span>N</span>次猜拳、小<span>A</span>出拳的周期长度,小<span>B</span>出拳的周期长度。数与数之间以一个空格分隔。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 第二行包含<span>NA</span>个整数,表示小<span>A</span>出拳的规律,第三行包含<span>NB</span>个整数,表示小<span>B</span>出拳的规律。其中,<span>0</span>表示剪刀<span>1</span>表示石头<span>2</span>表示<span>3</span>表示蜥蜴人<span>  4</span>表示斯波克。数与数之间以一个空格分隔。<span></span> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输出文件名为<span>rps.out</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 输出一行,<span>  </span>包含两个整数,以一个空格分隔,分别表示小<span>A</span>、小<span>B</span>的得分。<span></span> </p>

【输入输出样例1 10 5 6 0 1 2 3 4 0 3 4 2 1 0 【输入输出样例2 9 5 5 0 1 2 3 4 1 0 3 2 4

【输入输出样例1 6 2 【输入输出样例2 4 4

0

<p class="MsoNormal"> <b>【数据说明】<span></span></b> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>100%</span>的数据,<span>0 < N </span>≤<span> 200</span><span>0 < NA  </span>≤<span>  200</span><span>  0 < NB  </span>≤<span>  200</span><span></span> </p>

NOIP2014DAY1(一)

2017-07-28 22:31:56

1

128

N

1

1

0

1873

联合权值

<p class="MsoNormal" style="text-indent:21.0pt;"> 无向连通图<span>G</span><span>n</span>个点,<span>n-1</span>条边。点从<span>1</span><span>n</span>依次编号,编号为<span>i</span>的点的权值为<span>Wi  </span>,每条边的长度均为<span>1</span>。图上两点<span>(u, v)</span>的距离定义为<span>u</span>点到<span>v</span>点的最短距离。对于图<span>G</span>上的点对<span>(u, v)</span>,若它们的距离为<span>2</span>,则它们之间会产生<b>W</b><b>u</b><b>×</b><b>W</b><b>v</b>的联合权值。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 请问图<span>G</span>上所有可产生联合权值的<b>有序点对</b>中,联合权值最大的是多少?所有联合权值之和是多少?<span></span> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输入文件名为<span>link.in</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 第一行包含<span>1</span>个整数<span>n</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 接下来<span>n-1</span>行,每行包含<span>2</span>个用空格隔开的正整数<span>u</span><span>v</span>,表示编号为<span>u</span>和编号为<span>v</span>的点之间有边相连。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 最后<span>1</span>行,包含<span>n</span>个正整数,每两个正整数之间用一个空格隔开,其中第<span>i</span>个整数表示图<span>G</span>上编号为<span>i</span>的点的权值为<span>Wi</span><span></span> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输出文件名为<span>link.out</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 输出共<span>1</span>行,包含<span>2</span>个整数,之间用一个空格隔开,依次为图<span>G</span>上联合权值的最大值和所有联合权值之和。<b>由于所有联合权值之和可能很大,输出它时要对<span>10007</span>取余。</b> <span></span> </p>

5 1 2 2 3 3 4 4 5 1 5 2 3 10

20 74

0

<p class="MsoNormal"> <b>【样例说明】<span></span></b> </p> <p class="MsoNormal"> <b><img src="/JudgeOnline/upload/image/20170728/20170728223309_91465.png" alt="" /><br /> </b> </p> <p class="MsoNormal"> <b> <p class="MsoNormal" style="text-indent:21.0pt;"> 本例输入的图如上所示,距离为<span>2</span>的有序点对有<span>(1,3)</span><span>(2,4)</span><span>(3,1)</span><span>(3,5)</span><span>(4,2)</span><span>(5,3)</span>。其联合权值分别为<span>2</span><span>15</span><span>2</span><span>20</span><span>15</span><span>20</span>。其中最大的是<span>20</span>,总和为<span>74</span><span></span> </p> <p class="MsoNormal"> <b>【数据说明】<span></span></b> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>30%</span>的数据,<span>1<</span>≤100<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>60%</span>的数据,<span>1<</span>≤2000<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>100%</span>的数据,<span>1<</span>≤200,000<span>0<</span>Wi ≤<span>10,000</span><b></b> </p> </b> </p>

NOIP2014DAY1(二)

2017-07-28 22:33:32

1

128

N

1

1

0

1874

飞扬的小鸟

<p class="MsoNormal" style="text-indent:21.0pt;"> <br /> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> Flappy Bird 是一款风靡一时的休闲手机游戏。玩家需要不断控制点击手机屏幕的频率来调节小鸟的飞行高度,让小鸟顺利通过画面右方的管道缝隙。如果小鸟一不小心撞到了水管或者掉在地上的话,便宣告失败。 </p> <p class="MsoNormal" style="text-align:center;text-indent:21pt;"> <img src="/JudgeOnline/upload/image/20170728/20170728223525_49435.png" alt="" /> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 为了简化问题,我们对游戏规则进行了简化和改编:<span></span> </p> <p class="ListParagraph" style="margin-left:42.0pt;text-indent:-21.0pt;"> 1.   游戏界面是一个长为<span>n</span>,高 为<span>m</span>的二维平面,其中有<span>k</span>个管道(忽略管道的宽度)。<span></span> </p> <p class="ListParagraph" style="margin-left:42.0pt;text-indent:-21.0pt;"> 2.   小鸟始终在游戏界面内移动。小鸟从游戏界面最左边任意整数高度位置出发,到达游戏界面最右边时,游戏完成。<span></span> </p> <p class="ListParagraph" style="margin-left:42.0pt;text-indent:-21.0pt;"> 3.   小鸟每个单位时间沿横坐标方向右移的距离为<span>1</span>,竖直移动的距离由玩家控制。如果点击屏幕,小鸟就会上升一定高度<span>X</span>,每个单位时间可以点击多次,效果叠加;如果不点击屏幕,小鸟就会下降一定高度<span>Y</span>。小鸟位于横坐标方向不同位置时,上升的高度<span>X</span>和下降的高度<span>Y</span>可能互不相同。<span></span> </p> <p class="ListParagraph" style="margin-left:42.0pt;text-indent:-21.0pt;"> 4.   小鸟高度等于<span>0</span>或者小鸟碰到管道时,游 戏 失 败 。小 鸟 高 度 为<span>m</span>时,无法再上升。 </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 现在,请你判断是否可以完成游戏。如果可以,输出最少点击屏幕数;否则,输出小鸟<span>最多可以通过多少个管道缝隙。</span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <span></span> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输入文件名为<span> bird.in</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <span>1</span>行有<span>3</span>个整数<span>n</span><span>m</span><span>k</span>,分别表示游戏界面的长度,高度和水管的数量,每两个整数之间用一个空格隔开;<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 接下来的<span>n</span>行,每行<span>2</span>个用一个空格隔开的整数<span>X</span><span>Y</span>,依次表示在横坐标位置<span>0~n-1</span>上玩家点击屏幕后,小鸟在下一位置上升的高度<span>X</span>,以及在这个位置上玩家不点击屏幕时,小鸟在下一位置下降的高度<span>Y</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 接下来<span>k</span>行,每行<span>3</span>个整数<span>P</span><span>L</span><span>H</span>,每两个整数之间用一个空格隔开。每行表示一个管道,其中<span>P</span>表示管道的横坐标,<span>L</span>表示此管道缝隙的下边沿高度为<span>L</span><span>H</span>表示管道缝隙上边沿的高度(输入数据保证<span>P</span>各不相同,但不保证按照大小顺序给出)。<span></span> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输出文件名为<span>bird.out</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 共两行。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 第一行,包含一个整数,如果可以成功完成游戏,则输出<span>1</span>,否则输出<span>0</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 第二行,包含一个整数,如果第一行为<span>1</span>,则输出成功完成游戏需要最少点击屏幕数,否则,输出小鸟最多可以通过多少个管道缝隙。<span></span> </p>

【输入输出样例1 10 10 6 3 9 9 9 1 2 1 3 1 2 1 1 2 1 2 1 1 6 2 2 1 2 7 5 1 5 6 3 5 7 5 8 8 7 9 9 1 3 【输入输出样例2 10 10 4 1 2 3 1 2 2 1 8 1 8 3 2 2 1 2 1 2 2 1 2 1 0 2 6 7 9 9 1 4 3 8 10

【输入输出样例1 1 6 【输入输出样例2 0 3

0

<p class="MsoNormal"> <b>【输入输出样例说明】<span></span></b> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 如下图所示,蓝色直线表示小鸟的飞行轨迹,红色直线表示管道。 <span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <img src="/JudgeOnline/upload/image/20170728/20170728223654_86511.png" alt="" /> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <p class="MsoNormal"> 【数据范围】<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>30%</span>的数据:<span>5</span>≤<span>n</span>≤<span>10</span><span>5</span>≤<span>m</span>≤<span>10</span><span>k=0</span>,保证存在一组最优解使得同一单位时间最多点击屏幕<span>3</span>次; <span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>50%</span>的数据:<span>5</span>≤<span>n</span>≤<span>20</span><span>5</span>≤<span>m</span>≤<span>10</span>,保证存在一组最优解使得同一单位时间最多点击屏幕<span>3</span>次;<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>70%</span>的数据:<span>5</span>≤<span>n</span>≤<span>1000</span><span>5</span>≤<span>m</span>≤<span>100</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>100%</span>的数据:<span>5</span>≤<span>n</span>≤<span>10000</span><span>5</span>≤<span>m</span>≤<span>1000</span><span>0</span>≤<span>k<n</span><span>0<X<m</span><span>0<Y<m</span><span>0<P<n</span><span>0</span>≤<span>L<H </span>≤<span>m</span><span>L+1<H</span><span></span> </p> </p>

NOIP2014DAY1(三)

2017-07-28 22:37:13

1

128

N

0

1

0

1875

无线网络发射器选址

<p class="MsoNormal" style="text-indent:21.0pt;"> 随着智能手机的日益普及,人们对无线网的需求日益增大。某城市决定对城市内的公共场所覆盖无线网。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 假设该城市的布局为由严格平行的<span>129</span>条东西向街道和<span>129</span>条南北向街道所形成的网格状,并且相邻的平行街道之间的距离都是恒定值<span>1</span>。东西向街道从北到南依次编号为<span>0,1,2</span>…<span>128,</span>南北向街道从西到东依次编号为<span>0,1,2</span>…<span>128</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 东西向街道和南北向街道相交形成路口,规定编号为<span>x</span>的南北向街道和编号为<span>y</span>的东西向街道形成的路口的坐标是(<span>x, y</span>)。 在 某 些 路 口 存 在 一 定 数 量 的 公 共 场 所 。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 由于政府财政问题,只能安装一个大型无线网络发射器。该无线网络发射器的传播范围是一个以该点为中心,边长为<span>2*d</span>的正方形。传播范围包括正方形边界。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 例如下图是一个<span>d = 1</span>的无线网络发射器的覆盖范围示意图。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <img src="/JudgeOnline/upload/image/20170728/20170728223816_49770.png" alt="" width="500" height="177" title="" align="" /> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <p class="MsoNormal" style="text-indent:21.0pt;"> 现在政府有关部门准备安装一个传播参数为<span>d</span>的无线网络发射器,希望你帮助他们在城市内找出合适的安装地点,使得覆盖的公共场所最多。<span></span> </p> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输入文件名为<span>wireless.in</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 第一行包含一个整数<span>d</span>,表示无线网络发射器的传播距离。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 第二行包含一个整数<span>n</span>,表示有公共场所的路口数目。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 接下来<span>n</span>行,每行给出三个整数<span>x, y, k,  </span>中间用一个空格隔开,分别代表路口的坐标<span>(x, y)</span>以及该路口公共场所的数量。同一坐标只会给出一次。<span></span> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输出文件名为<span>wireless.out</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 输出一行,包含两个整数,用一个空格隔开,分别表示能覆盖最多公共场所的安装地点方案数,以及能覆盖的最多公共场所的数量。<span></span> </p>

1 2 4 4 10 6 6 20

1 30

0

<p class="MsoNormal"> <b>【数据说明】<span></span></b> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>100%</span>的数据,<span>1 </span>≤<span> d </span>≤<span> 20</span><span>1 </span>≤<span> n </span>≤<span>  20</span><span> 0 </span>≤<span> x </span>≤<span> 128, 0 </span>≤<span> y </span>≤<span>  128, 0 < k </span>≤<span> 1,000,000</span><span></span> </p>

NOIP2014DAY2(一)

2017-07-28 22:39:04

1

128

N

1

1

0

1876

寻找道路

<p class="MsoNormal" style="text-indent:21.0pt;"> 在有向图<span>G</span>中,每条边的长度均为<span>1</span>,现给定起点和终点,请你在图中找一条从起点到终点的路径,该路径满足以下条件:<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 1.路径上的所有点的出边所指向的点都直接或间接与终点连通。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 2.在满足条件<span>1</span>的情况下使路径最短。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 注意:图<span>G</span>中可能存在重边和自环,题目保证终点没有出边。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 请你输出符合条件的路径的长度。<span></span> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输入文件名为<span>road.in</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 第一行有两个用一个空格隔开的整数<span>n</span><span>m</span>,表示图有<span>n</span>个点和<span>m</span>条边。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 接下来的<span>m</span>行每行<span>2</span>个整数<span>x</span><span>y</span>,之间用一个空格隔开,表示有一条边从点<span>x</span>指向点<span>y</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 最后一行有两个用一个空格隔开的整数<span>s</span><span>t</span>,表示起点为<span>s</span>,终点为<span>t</span><span></span> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输出文件名为<span>road.out</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 输出只有一行,包含一个整数,表示满足题目描述的最短路径的长度。如果这样的路径不存在,输出<span>-1</span><span></span> </p>

【输入输出样例1 3 2 1 2 2 1 1 3 【输入输出样例2 6 6 1 2 1 3 2 6 2 5 4 5 3 4 1 5

【输入输出样例1 -1 【输入输出样例2 3

0

<p class="MsoNormal"> <b>【输入输出样例1说明】<span></span></b> </p> <p class="MsoNormal"> <b><img src="/JudgeOnline/upload/image/20170728/20170728224145_17502.png" alt="" /><br /> </b> </p> <p class="MsoNormal"> <b> <p class="MsoNormal" style="text-indent:21.0pt;"> 如上图所示,箭头表示有向道路,圆点表示城市。起点<span>1</span>与终点<span>3</span>不连通,所以满足题目描述的路径不存在,故输出<span>-1</span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <b></b> </p> </b> </p> <p class="MsoNormal"> <b> <p class="MsoNormal"> <b>【输入输出样例2说明】<span></span></b> </p> <img src="/JudgeOnline/upload/image/20170728/20170728224204_26002.png" alt="" /><br /> </b> </p> <p class="MsoNormal"> <b> <p class="MsoNormal" style="text-indent:21.0pt;"> 如上图所示,满足条件的路径为<span>1->3->4->5</span>。注意点<span>2</span>不能在答案路径中,因为点<span>2</span>连了一条边到点<span>6</span>,而点<span>6</span>不与终点<span>5</span>连通。 </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <b></b> </p> </b> </p> <p class="MsoNormal"> <b> <p class="MsoNormal"> 【数据说明】<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>30%</span>的数据,<span>0< n </span>≤10<span>0< m </span>≤20<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>60%</span>的数据,<span>0< n </span>≤100<span>0< m </span>≤2000<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>100%</span>的数据,<span>0< n </span>≤10,000<span>0< m </span>≤200,000<span>0< x</span>,y,s,t≤<span>n</span><span>x</span>≠<span>t</span><b></b> </p> </b> </p>

NOIP2014DAY2(二)

2017-07-28 22:42:24

1

128

N

1

1

0

1877

解方程

<p class="MsoNormal" style="text-indent:21.0pt;"> 已知多项式方程:<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <img src="/JudgeOnline/upload/image/20170728/20170728224306_94682.png" alt="" /> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <br /> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 求这个方程在<span>[1, m]</span>内的整数解(<span>n</span><span>m</span>均为正整数)。<span></span> </p> <p> <br /> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输入文件名为<span>equation.in</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 输入共<span>n+2</span>行。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 第一行包含<span>2</span>个整数<span>n</span><span>m</span>,每两个整数之间用一个空格隔开。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 接下来的<span>n+1</span>行每行包含一个整数,依次为a<sub>0</sub>,a<sub>1</sub>,a<sub>2</sub>,……,a<sub>n</sub> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输出文件名为<span>equation.out</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 第一行输出方程在<span>[1, m]</span>内的整数解的个数。<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 接下来每行一个整数,按照从小到大的顺序依次输出方程在<span>[1, m]</span>内的一个整数解。<span></span> </p>

【输入输出样例1 2 10 1 -2 1 【输入输出样例2 2 10 2 -3 1 【输入输出样例3 2 10 1 3 2

【输入输出样例1 1 1 【输入输出样例2 2 1 2 【输入输出样例3 0

0

<p class="MsoNormal"> <b>【数据说明】<span></span></b> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>30%</span>的数据,<span>0<</span>n≤2|a<sub>i</sub>|≤<span>100</span>a<sub>n</sub>≠<span>0</span><span>m</span>≤100<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>50%</span>的数据,<span>0<</span>n≤100|a<sub>i</sub>|≤<span>10<sup>100</sup></span>a<sub>n</sub>≠<span>0</span>m≤100<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>70%</span>的数据,<span>0<</span>n≤100|a<sub>i</sub>|≤<span>10<sup>10000</sup></span>a<sub>n</sub>≠<span>0</span>m≤10000<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span>100%</span>的数据,<span>0<</span>n≤100|a<sub>i</sub>|≤<span>10<sup>10000</sup></span>a<sub>n</sub>≠<span>0</span>m≤1000000<span></span> </p>

NOIP2014DAY2(三)

2017-07-28 22:45:52

1

128

N

0

0

0

1878

转圈游戏

<p class="MsoNormal" style="text-indent:21pt;"> n 个小伙伴(编号从 0  n-1)围坐一圈玩游戏。按照顺时针方向给 n 个位置编号,从 0  n-1。最初,第 0 号小伙伴在第 0 号位置,第 1 号小伙伴在第 1 号位置,……,依此类推。 </p> <p class="MsoNormal" style="text-indent:21pt;"> 游戏规则如下:每一轮第<span> 0 </span>号位置上的小伙伴顺时针走到第<span> m </span>号位置,第<span> 1 </span>号位置小伙伴走到第<span> m+1 </span>号位置,……,依此类推,第<span>n </span> m号位置上的小伙伴走到第<span> 0 </span>号位置,第<span>n-m+1 </span>号位置上的小伙伴走到第<span> 1 </span>号位置,……,第<span> n-1 </span>号位置上的小伙伴顺时针走到第<span>m-1 </span>号位置。<span></span> </p> <p class="MsoNormal" style="text-indent:22pt;"> 现在,一共进行了<span> 10<sup>k </sup></span>轮,请问<span> x </span>号小伙伴最后走到了第几号位置。<span></span> </p>

<p class="MsoNormal" style="text-indent:22pt;"> 输入文件名为<span> circle.in</span><span></span> </p> <p class="MsoNormal" style="text-indent:22pt;"> 输入共<span> 1 </span>行,包含<span> 4 </span>个整数<span> n</span><span>m</span><span>k</span><span>x</span>,每两个整数之间用一个空格隔开。<span></span> </p>

<p class="MsoBodyText" style="text-indent:20.8pt;margin-left:0cm;"> 输出文件名为 circle.out<span></span> </p> <p class="MsoBodyText" style="text-indent:20.8pt;margin-left:0cm;"> 输出共 1 行,包含 1 个整数,表示 10<sup>k </sup>轮后 x 号小伙伴所在的位置编号。<span></span> </p>

10 3 4 5

5

0

<p class="MsoBodyText"> <b>【数据说明】</b><b><span></span></b> </p> <p class="MsoNormal" style="text-indent:22pt;"> 对于<span> 30%</span>的数据,<span>0 < </span><span>k </span><span>< 7</span> <span></span> </p> <p class="MsoNormal" style="text-indent:22pt;"> 对于<span> 80%</span>的数据,<span>0 < </span><span>k </span><span>< 10<sup>7</sup></span><span></span> </p> <p class="MsoNormal" style="text-indent:22pt;"> 对于<span> 100%</span>的数据,<span>1 < </span><span>n</span><span>< 1,000,000</span><span>0 <</span><span>m</span><span> <</span><span>n</span><span> </span><span>0</span><span> ≤ x ≤ n</span><span>0 < </span><span>k</span><span>< 10<sup>9</sup></span><span></span> </p>

NOIP2013DAY1(一)

2017-12-30 14:17:52

1

128

N

22

47

0

1879

火柴排队

<p class="MsoNormal" style="text-indent:21.0pt;"> 涵涵有两盒火柴,每盒装有<span> n </span>根火柴,每根火柴都有一个高度。现在将每盒中的火柴各自排成一列,同一列火柴的高度互不相同,两列火柴之间的距离定义为:<img src="/JudgeOnline/upload/image/20170729/20170729085742_37065.png" alt="" /><span>,其中</span><span> ai </span><span>表示第一列火柴中第</span><span> i </span><span>个火柴的高度,</span><span>bi </span><span>表示第二列火柴中第</span><span> i </span><span>个火柴的高度。</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 每列火柴中相邻两根火柴的位置都可以交换,请你通过交换使得两列火柴之间的距离最 小。请问得到这个最小的距离,最少需要交换多少次?<b>如果这个数字太大,请输出这个最小交换次数对<span> 99,999,997 </span>取模的结果。<span></span></b> </p>

<p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 输入文件为 match.in<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 共三行,第一行包含一个整数 n,表示每盒中火柴的数目。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.8pt;"> 第二行有 n 个整数,每两个整数之间用一个空格隔开,表示第一列火柴的高度。 <span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.8pt;"> 第三行有 n 个整数,每两个整数之间用一个空格隔开,表示第二列火柴的高度。<span></span> </p>

<p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 输出文件为 match.out<span></span> </p> <p class="MsoNormal" style="text-indent:20.8pt;"> 输出共一行,包含一个整数,表示<b><u>最少交换次数对</u></b><b><u> </u></b><b><u>99,999,997</u></b><b><u> </u></b><b><u>取模的结果</u></b> </p>

【输入输出样例 1 4 2 3 1 4 3 2 1 4 【输入输出样例 2 4 1 3 4 2 1 7 2 4

【输入输出样例 1 1 【输入输出样例 2 2

0

<p class="MsoBodyText" style="margin-left:0cm;"> <b>【输入输出样例1说明】</b><b><span></span></b> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 最小距离是 0,最少需要交换 1 次,比如:交换第 1 列的前 2 根火柴或者交换第 2 列的前 2 根火柴。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> <br /> </p> <p class="MsoBodyText" style="margin-left:0cm;"> <b>【输入输出样例2说明】</b><b><span></span></b> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 最小距离是<span> 10</span>,最少需要交换<span> 2 </span>次,比如:交换第<span> 1 </span>列的中间<span> 2 </span>根火柴的位置,再交换第<span> 2 </span>列中后<span> 2 </span>根火柴的位置。<span></span> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> <p class="MsoNormal"> <b>【数据范围】</b><b><span></span></b> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 对于<span> 10%</span>的数据,<span> 1 ≤ n ≤ 10</span><span></span> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 对于<span> 30%</span>的数据,<span>1 ≤ n ≤ 100</span><span></span> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 对于<span> 60%</span>的数据,<span>1 ≤ n ≤ 1,000</span><span></span> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 对于<span> 100%</span>的数据,<span>1 ≤ n ≤ 100,000</span><span>0 ≤</span>火柴高度<span>≤ 2<sup>31</sup>  1</span><span></span> </p> </p> <p> <br /> </p>

NOIP2013DAY1(二)

2017-07-29 09:00:03

1

128

N

5

6

0

1880

货车运输

<p class="MsoNormal" style="text-align:justify;text-indent:22.0pt;"> <span>A </span>国有<span> n </span>座城市,编号从<span> 1 </span><span> n</span>,城市之间有<span> m </span>条双向道路。每一条道路对车辆都有重量限制,简称限重。现在有 <span>q </span>辆货车在运输货物,司机们想知道每辆车在不超过车辆限重的情况下,最多能运多重的货物。<span></span> </p>

<p class="MsoBodyText" style="margin-left:0cm;text-indent:20.8pt;"> 输入文件名为 truck.in<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 输入文件第一行有两个用一个空格隔开的整数 n<span>m</span>,表示 <span>A </span>国有 <span>n </span>座城市和 <span>m </span>条道路。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:21.0pt;"> 接下来 <span>m </span>行每行 <span>3 </span>个整数 <span>x</span>yz,每两个整数之间用一个空格隔开,表示从 <span>x </span>号城市到 <span>y </span>号城市有一条限重为 <span>z </span>的道路。注意:<span>x</span> 不等于 y,两座城市之间可能有多条道路。 <span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 接下来一行有一个整数 q,表示有 <span>q </span>辆货车需要运货。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.8pt;"> 接下来 <span>q </span>行,每行两个整数 x<span>y</span>,之间用一个空格隔开,表示一辆货车需要从 <span>x </span>城市 运输货物到 <span>y </span>城市,注意:<span>x</span><span> </span>不等于 y<span></span> </p>

<p class="MsoBodyText" style="margin-left:0cm;text-indent:20.8pt;"> 输出文件名为 truck.out<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.8pt;"> 输出共有 <span>q </span>行,每行一个整数,表示对于每一辆货车,它的最大载重是多少。如果货车不能到达目的地,输出<span>-1</span><span></span> </p>

4 3 1 2 4 2 3 3 3 1 1 3 1 3 1 4 1 3

3 -1 3

0

<p class="MsoBodyText" style="margin-left:0cm;"> <b>【数据说明】</b> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 对于<span> 30%</span>的数据,<span>0 < n < 1,000</span><span>0 < m < 10,000</span><span>0 < </span><span>q</span><span>< 1,000</span> <span></span> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 对于<span> 60%</span>的数据,<span>0 < n < 1,000</span><span>0 < m < 50,000</span><span>0 < </span><span>q</span><span>< 1,000</span><span></span> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 对于<span> 100%</span>的数据,<span>0 < n < 10,000</span><span>0 < m < 50,000</span><span>0 < </span><span>q</span><span>< 30,000</span><span>0 ≤ z ≤ 100,000</span><span></span> </p>

NOIP2013DAY1(三)

2017-07-29 09:12:49

1

128

N

0

0

0

1881

积木大赛

<p class="MsoNormal" style="text-indent:21.0pt;"> 春春幼儿园举办了一年一度的积木大赛。今年比赛的内容是搭建一座宽度为<span>n</span>的大厦,大厦可以看成由<span>n</span>块宽度为<span>1</span>的积木组成,第i块积木的最终高度需要是i<span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 在搭建开始之前,没有任何积木(可以看成块高度为<span> 0 </span>的积木)。接下来每次操作,小朋友们可以选择一段连续区间<span>[L,R]</span>,然后将第<span>L</span>块到第R块之间(含第<span> L </span>块和第<span> R </span>块)所有积木的高度分别增加<span>1</span><span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> <span>M</span>是个聪明的小朋友,她很快想出了建造大厦的最佳策略,使得建造所需的操作次数最少。但她不是一个勤于动手的孩子,所以想请你帮忙实现这个策略,并求出最少的操作次数。<span></span> </p>

<p class="MsoNormal" style="text-indent:21.0pt;"> 输入文件为 block.in </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 输入包含两行,第一行包含一个整数<span>n</span>,表示大厦的宽度。 <span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 第二行包含<span>n</span>个整数,第i个整数为i<span></span> </p>

<p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 输出文件为 block.out </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 仅一行,即建造所需的最少操作数。<span></span> </p>

5 2 3 4 1 2

5

0

<p class="MsoBodyText" style="margin-left:0cm;"> <b>【样例解释】<span></span></b> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 其中一种可行的最佳方案,依次选择 </p> <p class="MsoNormal" style="text-indent:21.0pt;"> [1,5]   [1,3]   [2,3]   [3,3]   [5,5] </p> <p class="MsoNormal"> <b>【数据范围】<span></span></b> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于<span> 30%</span>的数据,有<span>1 ≤ n ≤ 10</span> <span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于 70%的数据,有1 ≤ n ≤ 1000 </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 对于 100%的数据,有1 ≤ n ≤ 1000000 ≤ hi≤10000 </p>

NOIP2013DAY2(一)

2017-07-29 09:16:37

1

128

N

28

47

0

1882

花匠

<p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 花匠栋栋种了一排花,每株花都有自己的高度。花儿越长越大,也越来越挤。栋栋决定把这排中的一部分花移走,将剩下的留在原地,使得剩下的花能有空间长大,同时,栋栋希望剩下的花排列得比较别致。<span></span> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 具体而言,栋栋的花的高度可以看成一列整数1, 2,  , n。设当一部分花被移走后,剩下的花的高度依次为g<sub>1</sub>, g<sub>2</sub>, … , g<sub>m</sub>,则栋栋希望下面两个条件中至少有一个满足:<span></span> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 条件<span> A</span>:对于所有的<span>1</span><span>≤</span>i<span>≤m/2</span>,有g<sub>2</sub><sub>i </sub> > g<sub>2i-1</sub>,同时对于所有的<span>1</span><span>≤</span>i<span>≤<span>m/2</span></span>,有g<sub>2</sub><sub>i </sub> > g<sub>2i+1</sub> <span></span> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 条件<span> B</span>:对于所有的<span>1</span><span>≤</span>i<span>≤<span>m/2</span></span>,有g<sub>2</sub><sub>i </sub> < g<sub>2i-1</sub>,同时对于所有的<span>1</span><span>≤</span>i<span>≤<span>m/2</span></span>,有g<sub>2</sub><sub>i </sub> < g<sub>2i+1</sub><span></span> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 注意上面两个条件在 m = 1时同时满足,当 m > 1时最多有一个能满足。 </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 请问,栋栋最多能将多少株花留在原地。 </p>

<p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 输入文件为 flower.in<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 输入的第一行包含一个整数,表示开始时花的株数。 <span></span> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 第二行包含个整数,依次为<span>1, </span><span>2,  , </span>n,表示每株花的高度。<span></span> </p>

<p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 输出文件为 flower.out<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 输出一行,包含一个整数,表示最多能留在原地的花的株数。<span></span> </p>

5 5 3 2 1 2

3

0

<p class="MsoBodyText" style="margin-left:0cm;"> <b>【输入输出样例说明】</b><b><span></span></b> </p> <p class="MsoBodyText" style="margin-left:0cm;text-indent:20.6pt;"> 有多种方法可以正好保留 3 株花,例如,留下第 145 株,高度分别为 512,满足条件B </p> <p class="MsoNormal"> <b>【数据范围】<span></span></b> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 对于<span> 20%</span>的数据,<span>n ≤ 10</span> <span></span> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 对于<span> 30%</span>的数据,<span>n ≤ 25</span><span></span> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 对于<span> 70%</span>的数据,<span>n ≤ 1000</span><span>0 ≤ </span><span>n</span><span> 1000</span><span></span> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 对于<span> 100%</span>的数据,<span>1 ≤ n ≤ 100,000</span><span>0 ≤ </span><span>n</span><span> 1,000,000</span>,所有的<span>n</span>随机生成,所有随机数服从某区间内的均匀分布。 </p>

NOIP2013DAY2(二)

2017-07-29 09:19:57

1

128

N

6

14

0

1883

华容道

<p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> <span> B </span>最近迷上了华容道,可是他总是要花很长的时间才能完成一次。于是,他想到用编程来完成华容道:给定一种局面,华容道是否根本就无法完成,如果能完成,最少需要多少时间。<span></span> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;">  B 玩的华容道与经典的华容道游戏略有不同,游戏规则是这样的: </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 1.  在一个 n*m 棋盘上有 n*m 个格子,其中有且只有一个格子是空白的,其余 n*m-1个格子上每个格子上有一个棋子,每个棋子的大小都是 1*1 的; </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 2.  有些棋子是固定的,有些棋子则是可以移动的; </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 3.  任何与空白的格子相邻(有公共的边)的格子上的棋子都可以移动到空白格子上。游戏的目的是把某个指定位置可以活动的棋子移动到目标位置。 </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 给定一个棋盘,游戏可以玩<span> q </span>次,当然,每次棋盘上固定的格子是不会变的,但是棋盘上空白的格子的初始位置、指定的可移动的棋子的初始位置和目标位置却可能不同。第<span> i </span>次玩的时候,空白的格子在第<span> EX<sub>i</sub> </span>行第<span> EY<sub>i</sub> </span>列,指定的可移动棋子的初始位置为第<span> SX<sub>i</sub> </span>行第<span> SY<sub>i</sub> </span>列,目标位置为第<span> TX<sub>i</sub> </span>行第<span> TY<sub>i</sub> </span>列。<span></span> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 假设小 B 每秒钟能进行一次移动棋子的操作,而其他操作的时间都可以忽略不计。请你告诉小<span> B </span>每一次游戏所需要的最少时间,或者告诉他不可能完成游戏。<span></span> </p>

<p class="MsoBodyText" style="margin-left:0cm;text-align:justify;text-indent:20.6pt;"> 输入文件为 puzzle.in<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;text-indent:20.8pt;"> 第一行有 <span>3 </span>个整数,每两个整数之间用一个空格隔开,依次表示 n<span>m</span>  <span>q</span><span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;text-indent:20.8pt;"> 接下来的 <span>n </span>行描述一个 n*m 的棋盘,每行有 <span>m </span>个整数,每两个整数之间用一个空格隔开,每个整数描述棋盘上一个格子的状态,<span>0</span> 表示该格子上的棋子是固定的,<span>1</span> 表示该格子上的棋子可以移动或者该格子是空白的。<span></span> </p> <p class="MsoBodyText" style="margin-left:0cm;text-align:justify;text-indent:20.8pt;"> 接下来的 <span>q </span>行,每行包含 <span>6 </span>个整数依次是 EXi<span>EYi</span><span>SXi</span><span>SYi</span><span>TXi</span><span>TYi</span>,每两个整数之间用一个空格隔开,表示每次游戏空白格子的位置,指定棋子的初始位置和目标位置。 </p>

<p class="MsoNormal" style="text-indent:22.0pt;"> 输出文件名为<span> puzzle.out</span><span></span> </p> <p class="MsoNormal" style="text-indent:22.0pt;"> 输出有<span> q </span>行,每行包含<span> 1 </span>个整数,表示每次游戏所需要的最少时间,如果某次游戏无法完成目标则输出<span>1</span><span></span> </p>

3 4 2 0 1 1 1 0 1 1 0 0 1 0 0 3 2 1 2 2 2 1 2 2 2 3 2

2 -1

0

<p class="MsoBodyText" style="margin-left:0cm;"> <b>【输入输出样例说明】</b><b> <span></span></b> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 棋盘上划叉的格子是固定的,红色格子是目标位置,圆圈表示棋子,其中绿色圆圈表示目标棋子。<span></span> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 1. 第一次游戏,空白格子的初始位置是<span>  (3,2)</span>(图中空白所示),游戏的目标是将初始位置在<span>(1,2)</span>上的棋子(图中绿色圆圈所代表的棋子)移动到目标位置<span>(2,2)</span>(图中红色的格子)上。<span></span> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 移动过程如下:<span></span> </p> <p class="MsoNormal" style="text-align:left;text-indent:52.5pt;"> 初始状态<span>                                       </span>第一步之后<span>                          </span>第二步之后<img src="/JudgeOnline/upload/image/20170729/20170729092137_18992.png" alt="" /> </p> <p class="MsoNormal" style="text-align:justify;text-indent:52.5pt;"> <br /> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 2. 第二次游戏,空白格子的初始位置是(<span>1,2</span>)(图中空白所示),游戏的目标是将初始位置在(<span>2,2</span>)上的棋子(图中绿色圆圈所示)移动到目标位置<span>  (3,2)</span>上。<span></span> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 初始状态 </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> <img src="/JudgeOnline/upload/image/20170729/20170729092227_96523.png" alt="" /> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 要将指定块移入目标位置,必须先将空白块移入目标位置,空白块要移动到目标位置,必然是从位置(<span>2</span><span> 2</span>)上与当前图中目标位置上的棋子交换位置,之后能与空白块交换位置的只有当前图中目标位置上的那个棋子,因此目标棋子永远无法走到它的目标位置, 游戏无法完成。 </p> <p class="MsoNormal" style="text-align:justify;"> <b>【数据范围】<span></span></b> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 对于<span> 30%</span>的数据,<span>1 </span>≤<span> n, m </span>≤<span> 10</span><span>q = 1</span><span></span> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 对于<span> 60%</span>的数据,<span>1 </span>≤<span> n, m </span>≤<span> 30</span><span>q </span>≤<span> 10</span><span></span> </p> <p class="MsoNormal" style="text-align:justify;text-indent:21.0pt;"> 对于<span> 100%</span>的数据,<span>1 </span>≤<span> n, m </span>≤<span> 30</span><span>q </span>≤<span> 500</span> </p>

NOIP2013DAY2(三)

2017-07-29 09:26:25

1

128

N

0

1

0

1884

Vigenère密码

<p class="MsoNormal" style="margin-left:2.75pt;text-align:justify;text-indent:-.5pt;"> 16世纪法国外交家 Blaise de Vigenère 设计了一种多表密码加密算法<span>——</span>Vigenère 密码。Vigenère 密码的加密解密算法简单易用,且破译难度比较高,曾在美国南北战争中为南军所广泛使用。  在密码学中,我们称需要加密的信息为明文,用 M 表示;称加密后的信息为密文,用 C 表示;而密钥是一种参数,是将明文转换为密文或将密文转换为明文的算法中输入的数据,记为 k。 在 Vigenère 密码中,密钥 k 是一个字母串,k=k<sub>1</sub>k<sub>2</sub><span>…</span>k<sub>n</sub>。当明文 M=m<sub>1</sub>m<sub>2</sub><span>…</span>m<sub>n </sub>时,得到的密文 C=c<sub>1</sub>c<sub>2</sub><span>…</span>c<sub>n</sub>,其中 c<sub>i</sub>=m<sub>i</sub>®k<sub>i</sub>,运算®的规则如下表所示: </p> <p class="MsoNormal" style="margin-left:2.75pt;text-align:justify;text-indent:-.5pt;"> <img src="/JudgeOnline/upload/image/20170729/20170729112332_69870.png" alt="" width="500" height="493" title="" align="" /> </p> <p class="MsoNormal" style="margin-left:2.75pt;text-align:justify;text-indent:-.5pt;"> <p class="MsoNormal">       Vigenère 加密在操作时需要注意: <span></span> </p> <p class="MsoNormal" style="margin-left:42.0pt;text-indent:-18.0pt;"> 1.     ®运算忽略参与运算的字母的大小写,并保持字母在明文 M 中的大小写形式; <span></span> </p> <p class="MsoNormal" style="margin-left:42.0pt;text-indent:-18.0pt;"> 2.     当明文 M 的长度大于密钥 k 的长度时,将密钥 k 重复使用。 <span></span> </p> <p class="MsoNormal" style="margin-left:24.0pt;text-indent:0cm;"> 例如,明文 M=Helloworld,密钥 k=abc 时,密文 C=Hfnlpyosnd <span></span> </p> <table class="MsoNormalTable ke-zeroborder" border="0" cellspacing="0" cellpadding="0" width="653" style="width:391.5pt;"> <tbody> <tr> <td width="58" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:宋体;">明文</span><span style="font-family:""> </span><span></span> </p> </td> <td width="61" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">H </span><span></span> </p> </td> <td width="60" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">e </span><span></span> </p> </td> <td width="59" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">l </span><span></span> </p> </td> <td width="59" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">l </span><span></span> </p> </td> <td width="60" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">o </span><span></span> </p> </td> <td width="61" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">w </span><span></span> </p> </td> <td width="60" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">o </span><span></span> </p> </td> <td width="59" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">r </span><span></span> </p> </td> <td width="58" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;text-indent:0cm;"> <span style="font-family:"">l </span><span></span> </p> </td> <td width="58" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">d </span><span></span> </p> </td> </tr> <tr> <td width="58" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:宋体;">密钥</span><span style="font-family:""> </span><span></span> </p> </td> <td width="61" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">a </span><span></span> </p> </td> <td width="60" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">b </span><span></span> </p> </td> <td width="59" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">c </span><span></span> </p> </td> <td width="59" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">a </span><span></span> </p> </td> <td width="60" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">b </span><span></span> </p> </td> <td width="61" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">c </span><span></span> </p> </td> <td width="60" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">a </span><span></span> </p> </td> <td width="59" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">b </span><span></span> </p> </td> <td width="58" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;text-indent:0cm;"> <span style="font-family:"">c </span><span></span> </p> </td> <td width="58" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">a </span><span></span> </p> </td> </tr> <tr> <td width="58" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:宋体;">密文</span><span style="font-family:""> </span><span></span> </p> </td> <td width="61" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">H </span><span></span> </p> </td> <td width="60" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">f </span><span></span> </p> </td> <td width="59" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">n </span><span></span> </p> </td> <td width="59" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">l </span><span></span> </p> </td> <td width="60" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">p </span><span></span> </p> </td> <td width="61" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">y </span><span></span> </p> </td> <td width="60" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">o </span><span></span> </p> </td> <td width="59" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">s </span><span></span> </p> </td> <td width="58" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;text-indent:0cm;"> <span style="font-family:"">n </span><span></span> </p> </td> <td width="58" valign="top" style="border:solid black 1.0pt;"> <p class="MsoNormal" style="text-align:center;margin-left:0.1pt;text-indent:0cm;"> <span style="font-family:"">d</span> </p> </td> </tr> </tbody> </table> </p>

<p class="MsoNormal" style="margin-left:24.45pt;text-indent:-.5pt;"> 输入文件名为 vigenere.in <span></span> </p> <p class="MsoNormal" style="margin-left:24.7pt;"> 输入共 2 行。 <span></span> </p> <p class="MsoNormal" style="margin-left:24.7pt;"> 第一行为一个字符串,表示密钥 k,长度不超过 100,其中仅包含大小写字母。 </p> <p class="MsoNormal" style="margin-left:24.7pt;"> 第二行为一个字符串,表示经加密后的密文,长度不超过 1000,其中仅包含大小写字母。 </p>

<p class="MsoNormal" style="margin-left:24.45pt;text-indent:-.5pt;"> 输出文件名为 vigenere.out <span></span> </p> <p class="MsoNormal" style="margin-left:24.7pt;"> 输出共 1 行,一个字符串,表示输入密钥和密文所对应的明文。 <span></span> </p>

CompleteVictory Yvqgpxaimmklongnzfwpvxmniytm

Wherethereisawillthereisaway

0

<p class="MsoNormal" style="margin-left:2.75pt;text-align:justify;text-indent:-.5pt;"> 【数据说明】 对于 100%的数据,输入的密钥的长度不超过 100,输入的密文的长度不超过 1000,且都仅包含英文字母。 <span></span> </p>

NOIP2012DAY1(一)

2017-07-29 11:25:11

1

128

N

2

2

0

1885

国王游戏

<p class="MsoNormal" style="margin-left:2.75pt;text-align:justify;text-indent:-.5pt;">     恰逢 H 国国庆,国王邀请 n 位大臣来玩一个有奖游戏。首先,他让每个大臣在左、右手上面分别写下一个整数,国王自己也在左、右手上各写一个整数。然后,让这 n 位大臣排成一排,国王站在队伍的最前面。排好队后,所有的大臣都会获得国王奖赏的若干金币,每位大臣获得的金币数分别是:<b>排在该大臣前面的所有人的左手上的数的乘积除以他自己右手上的数,然后向下取整得到的结果</b> </p> <p class="MsoNormal" style="margin-left:2.75pt;text-align:justify;text-indent:-.5pt;">     国王不希望某一个大臣获得特别多的奖赏,所以他想请你帮他重新安排一下队伍的顺序,使得获得奖赏最多的大臣,所获奖赏尽可能的少。注意,国王的位置始终在队伍的最前面。 </p>

<p class="MsoNormal" style="margin-left:24.45pt;text-indent:-.5pt;"> 输入文件为 game.in </p> <p class="MsoNormal" style="margin-left:24.45pt;text-indent:-.5pt;"> 第一行包含一个整数 n,表示大臣的人数。 </p> <p class="MsoNormal" style="margin-left:24.45pt;text-indent:-.5pt;"> 第二行包含两个整数 a  b,之间用一个空格隔开,分别表示国王左手和右手上的整数。 接下来 n 行,每行包含两个整数 a  b,之间用一个空格隔开,分别表示每个大臣左手和右手上的整数。 </p> <p class="MsoNormal" style="margin-left:24.0pt;"> <span></span> </p>

<p class="MsoNormal"> 输出文件名为 game.out </p> <p class="MsoNormal"> 输出只有一行,包含一个整数,表示重新排列后的队伍中获奖赏最多的大臣所获得的金币数。 </p> <p class="MsoNormal"> <span></span> </p>

3 1 1 2 3 7 4 4 6

2

0

<p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21.0pt;"> 【输入输出样例说明】 </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21.0pt;"> <span>1</span><span>2</span><span>3</span>号大臣这样排列队伍,获得奖赏最多的大臣所获得金币数为<span>2</span> </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21.0pt;"> <span>1</span><span>3</span><span>2</span>这样排列队伍,获得奖赏最多的大臣所获得金币数为<span>2</span> </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21.0pt;"> <span>2</span><span>1</span><span>3</span>这样排列队伍,获得奖赏最多的大臣所获得金币数为<span>2</span> </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21.0pt;"> <span>2</span><span>3</span><span>1</span>这样排列队伍,获得奖赏最多的大臣所获得金币数为<span>9</span> </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21.0pt;"> <span>3</span><span>1</span><span>2</span>这样排列队伍,获得奖赏最多的大臣所获得金币数为<span>2</span> </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21.0pt;"> <span>3</span><span>2</span><span>1</span>这样排列队伍,获得奖赏最多的大臣所获得金币数为<span>9</span> </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21.0pt;"> 因此,奖赏最多的大臣最少获得 2 个金币,答案输出 2 </p> <p class="MsoNormal"> 【数据范围】 <span></span> </p> <p class="MsoNormal" style="margin-left:24.45pt;text-indent:-.5pt;"> 对于 20%的数据,有 1≤ n≤ 100<ab<8; 对于 40%的数据,有 1≤ n≤200 < ab < 8; 对于 60%的数据,有 1≤ n≤100; 对于 60%的数据,保证答案不超过 10<sup>9</sup> <span></span> </p> <p class="MsoNormal" style="margin-left:24.45pt;text-indent:-.5pt;"> 对于 100%的数据,有 1 ≤ n ≤1,0000< ab<10000 <b> </b> </p>

NOIP2012DAY1(二)

2017-07-29 11:30:55

1

128

N

1

1

0

1886

开车旅行

<p class="MsoNormal" style="margin-left:2.75pt;text-align:justify;text-indent:-.5pt;"> <img src="/JudgeOnline/upload/image/20170729/20170729115326_30018.png" alt="" width="600" height="89" title="" align="" /> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 旅行过程中,小 A 和小 B 轮流开车,第一天小 A 开车,之后每天轮换一次。他们计划选择一个城市 S 作为起点,一直向东行驶,并且最多行驶 X 公里就结束旅行。小 A 和小 B 的驾驶风格不同,小 B 总是沿着前进方向选择一个最近的城市作为目的地,而小 A 总是沿着前进方向选择第二近的城市作为目的地(注意:本题中如果当前城市到两个城市的距离相同,则认为离海拔低的那个城市更近)。如果其中任何一人无法按照自己的原则选择目的城市,或者到达目的地会使行驶的总距离超出 X 公里,他们就会结束旅行。 <span></span> </p> <p class="MsoNormal" style="margin-left:24.0pt;"> 在启程之前,小 A 想知道两个问题: <span></span> </p> <p class="MsoNormal" style="margin-left:2.25pt;text-align:justify;text-indent:21.0pt;"> 1.对于一个给定的 X=X<sub>0</sub>,从哪一个城市出发,小 A 开车行驶的路程总数与小 B 行驶的路程总数的比值最小(如果小 B 的行驶路程为 0,此时的比值可视为无穷大,且两个无穷大视为相等)。如果从多个城市出发,小 A 开车行驶的路程总数与小 B 行驶的路程总数的比值都最小,则输出海拔最高的那个城市。 <span></span> </p> <p class="MsoNormal" style="text-indent:21.0pt;"> 2. 对任意给定的 X=X<sub>i </sub>和出发城市 S<sub>i</sub>,小 A 开车行驶的路程总数以及小 B 行驶的路程总数。 <span></span> </p>

<p class="MsoNormal" style="margin-left:24.45pt;text-indent:-.5pt;"> 输入文件为 drive.in <span></span> </p> <p class="MsoNormal" style="margin-left:24.0pt;"> 第一行包含一个整数 N,表示城市的数目。 <span></span> </p> <p class="MsoNormal" style="margin-left:24.0pt;"> 第二行有 N 个整数,每两个整数之间用一个空格隔开,依次表示城市 1 到城市 N 的海<span>拔高度,即 H</span><sub>1</sub><span>H</span><sub>2</sub><span></span><span>……</span><span>H</span><sub>n</sub><span>,且每个 H</span><sub>i </sub><span>都是不同的。 第三行包含一个整数 X</span><sub>0</sub><span>。 第四行为一个整数 M,表示给定 M  S</span><sub>i </sub><span> X</span><sub>i</sub><span></span> </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21.0pt;"> <span></span> </p> <p class="MsoNormal" style="margin-left:24.0pt;"> 接下来的 M 行,每行包含 2 个整数 S<sub>i </sub> X<sub>i</sub>,表示从城市 S<sub>i </sub>出发,最多行驶 X<sub>i </sub>公里。 <span></span> </p>

<p class="MsoNormal"> 输出文件为 drive.out </p> <p class="MsoNormal"> 输出共 M+1 行。 </p> <p class="MsoNormal"> 第一行包含一个整数 S<sub>0</sub>,表示对于给定的 X<sub>0</sub>,从编号为 S<sub>0 </sub>的城市出发,小 A 开车行驶<span>的路程总数与小 B 行驶的路程总数的比值最小。</span> </p> <p class="MsoNormal"> <span>接下来的 M 行,每行包含 2 个整数,之间用一个空格隔开,依次表示在给定的 S</span><sub>i </sub><span></span>X<sub>i </sub>下小 A 行驶的里程总数和小 B 行驶的里程总数。   </p> <p class="MsoNormal"> <span></span> </p>

【输入输出样例 1 4 2 3 1 4 3 4 1 3 2 3 3 3 4 3 【输入输出样例 2 10 4 5 6 1 2 3 7 8 9 10 7 10 1 7 2 7 3 7 4 7 5 7 6 7 7 7 8 7 9 7 10 7

【输入输出样例 1 1 1 1 2 0 0 0 0 0 【输入输出样例 2 2 3 2 2 4 2 1 2 4 5 1 5 1 2 1 2 0 0 0 0 0

0

<p class="MsoNormal"> 【输入输出样例 1 说明】 <span></span> </p> <p class="MsoNormal"> <img src="/JudgeOnline/upload/image/20170729/20170729113402_19205.jpg" alt="" /> </p> <p class="MsoNormal"> 各个城市的海拔高度以及两个城市间的距离如上图所示。 </p> <p class="MsoNormal"> <span>如果从城市1出发,可以到达的城市为 2,3,4,这几个城市与城市1的距离分别为 1,1,2,但是由于城市3的海拔高度低于城市2,所以我们认为城市3离城市1最近,城市2离城市1第二近,所以小A会走到城市2。到达城市2后,前面可以到达的城市为3,4,这两个城市与城市2的距离分别为 2,1,所以城市4离城市2最近,因此小B会走到城市4。到达城市4后,前面已没有可到达的城市,所以旅行结束。</span> </p> <p class="MsoNormal"> <span>如果从城市2出发,可以到达的城市为3,4,这两个城市与城市2的距离分别为 2,1,由于城市3离城市2第二近,所以小A会走到城市3。到达城市3后,前面尚未旅行的城市为4,所以城市4离城市3最近,但是如果要到达城市4,则总路程为 2+3=5>3,所以小B会直接在城市3结束旅行。</span> </p> <p class="MsoNormal"> <span>如果从城市3出发,可以到达的城市为4,由于没有离城市3第二近的城市,因此旅行还未开始就结束了。</span> </p> <p class="MsoNormal"> <span>如果从城市4出发,没有可以到达的城市,因此旅行还未开始就结束了。</span> </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21pt;"> 【输入输出样例 2 说明】 </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21pt;"> X=7 时, </p> <p class="MsoNormal" style="text-indent:21pt;"> 如果从城市 1 出发,则路线为 1 -> 2 -> 3 -> 8 -> 9,小 A 走的距离为 1+2=3,小 B 走的距离为 1+1=2。(在城市 1 时,距离小 A 最近的城市是 2  6,但是城市 2 的海拔更高,视为与城市 1 第二近的城市,所以小 A 最终选择城市 2;走到 9 后,小 A 只有城市 10 可以走,没有第 2 选择可以选,所以没法做出选择,结束旅行) </p> <p class="MsoNormal" style="text-indent:21pt;"> 如果从城市 2 出发,则路线为 2 -> 6 -> 7 ,小 A 和小 B 走的距离分别为 24 </p> <p class="MsoNormal" style="text-indent:21pt;"> 如果从城市 3 出发,则路线为 3 -> 8 -> 9,小 A 和小 B 走的距离分别为 21 </p> <p class="MsoNormal" style="text-indent:21pt;"> 如果从城市 4 出发,则路线为 4 -> 6 -> 7,小 A 和小 B 走的距离分别为 24 </p> <p class="MsoNormal" style="text-indent:21pt;"> 如果从城市 5 出发,则路线为 5 -> 7 -> 8 ,小 A 和小 B 走的距离分别为 51 </p> <p class="MsoNormal" style="text-indent:21pt;"> 如果从城市 6 出发,则路线为 6 -> 8 -> 9,小 A 和小 B 走的距离分别为 51 </p> <p class="MsoNormal" style="text-indent:21pt;"> 如果从城市 7 出发,则路线为 7 -> 9 -> 10,小 A 和小 B 走的距离分别为 21 </p> <p class="MsoNormal" style="text-indent:21pt;"> 如果从城市 8 出发,则路线为 8 -> 10,小 A 和小 B 走的距离分别为 20 </p> <p class="MsoNormal" style="text-indent:21pt;"> 如果从城市 9 出发,则路线为 9,小 A 和小 B 走的距离分别为 00(旅行一开始就结束了)。 </p> <p class="MsoNormal" style="text-indent:21pt;"> 如果从城市 10 出发,则路线为 10,小 A 和小 B 走的距离分别为 00 </p> <p class="MsoNormal" style="text-indent:21pt;"> 从城市 2 或者城市 4 出发小 A 行驶的路程总数与小 B 行驶的路程总数的比值都最小,但是城市 2 的海拔更高,所以输出第一行为 2 </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21pt;"> 【数据范围】 </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21pt;"> 对于 30%的数据,有 1≤N≤201≤M≤20 </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21pt;"> 对于 40%的数据,有 1≤N≤1001≤M≤100 </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21pt;"> 对于 50%的数据,有 1≤N≤1001≤M≤1,000  </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21pt;"> 对于 70%的数据,有 1≤N≤1,0001≤M≤10,000 </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21pt;"> 对于 100%的数据,有 1≤N≤100,0001≤M≤10,000-1,000,000,000≤H<sub>i</sub>≤1,000,000,000 </p> <p class="MsoNormal" style="margin-left:23.25pt;text-indent:-21pt;"> 0≤X<sub>0</sub>≤1,000,000,0001≤S<sub>i</sub>≤N0≤X<sub>i</sub>≤1,000,000,000,数据保证 H<sub>i </sub>互不相同。 </p>

NOIP2012DAY1(三)

2017-07-29 11:53:55

1

128

N

0

0

0

1887

同余方程

求关于 <i>x</i> 的同余方程 <i>ax</i> ≡ 1 (mod <i>b</i>)的最小正整数解。

<p class="MsoNormal" align="left"> 输入文件为 mod.in </p> <p class="MsoNormal" align="left"> 输入只有一行,包含两个正整数 <i>a</i>, <i>b</i>,用一个空格隔开。 </p>

<div class="WordSection1"> <p class="MsoNormal" align="left"> 输出文件为 mod.out </p> </div> <p class="MsoNormal" align="left"> 输出只有一行,包含一个正整数 <i>x</i><sub>0</sub>,即最小正整数解。输入数据保证一定有解。 </p>

3 10

7

0

<div class="WordSection1"> <h3> <span style="font-family:SimSun;font-size:16px;"><strong>【数据范围】<br /> </strong></span><span style="font-family:SimSun;font-size:16px;"><strong>对于40%的数据,2≤</strong></span><i><span style="font-family:SimSun;font-size:16px;"><strong>b</strong></span></i><span style="font-family:SimSun;font-size:16px;"><strong>≤1,000<br /> </strong></span><span style="font-family:SimSun;font-size:16px;"><strong>对于60%的数据,2≤</strong></span><i><span style="font-family:SimSun;font-size:16px;"><strong>b</strong></span></i><span style="font-family:SimSun;font-size:16px;"><strong>≤50,000,000<br /> </strong></span><span style="font-family:SimSun;font-size:16px;"><strong>对于100%的数据,2≤</strong></span><i><span style="font-family:SimSun;font-size:16px;"><strong>a</strong></span></i><span style="font-family:SimSun;font-size:16px;"><strong>, </strong></span><i><span style="font-family:SimSun;font-size:16px;"><strong>b</strong></span></i><span style="font-family:SimSun;font-size:16px;"><strong>≤2,000,000,000</strong></span> </h3> </div>

NOIP2012DAY2(一)

2017-07-29 12:21:57

1

128

N

3

3

0

1888

借教室

<p class="MsoNormal" align="left"> 在大学期间,经常需要租借教室。大到院系举办活动,小到学习小组自习讨论,都需要向学校申请借教室。教室的大小功能不同,借教室人的身份不同,借教室的手续也不一样。 </p> <p class="MsoNormal" align="left"> 面对海量租借教室的信息,我们自然希望编程解决这个问题。 </p> <p class="MsoNormal" align="left"> 我们需要处理接下来n天的借教室信息,其中第i天学校有r<sub>i</sub>个教室可供租借。共有m份订单,每份订单用三个正整数描述,分别为d<sub>j</sub>, s<sub>j</sub>, t<sub>j</sub>,表示某租借者需要从第s<sub>j</sub>天到第t<sub>j</sub>天租借教室(包括第s<sub>j</sub>天和第t<sub>j</sub>天),每天需要租借d<sub>j</sub>个教室。 </p> <p class="MsoNormal" align="left"> 我们假定,租借者对教室的大小、地点没有要求。即对于每份订单,我们只需要每天提供d<sub>j</sub>个教室,而它们具体是哪些教室,每天是否是相同的教室则不用考虑。 </p> <p class="MsoNormal" align="left"> 借教室的原则是先到先得,也就是说我们要按照订单的先后顺序依次为每份订单分配教室。如果在分配的过程中遇到一份订单无法完全满足,则需要停止教室的分配,通知当前申请人修改订单。这里的无法满足指从第s<sub>j</sub>天到第t<sub>j</sub>天中有至少一天剩余的教室数量不足d<sub>j</sub>个。 </p> <p class="MsoNormal" align="left"> 现在我们需要知道,是否会有订单无法完全满足。如果有,需要通知哪一个申请人修改订单。 </p>

<div class="WordSection1"> <p class="MsoNormal" align="left"> 输入文件为 classroom.in </p> <p class="MsoNormal" align="left"> 第一行包含两个正整数n, m,表示天数和订单的数量。 </p> </div> <p class="MsoNormal" align="left"> 第二行包含n个正整数,其中第i个数为r<sub>i</sub>,表示第i天可用于租借的教室数量。 </p> <p class="MsoNormal" align="left"> 接下来有m行,每行包含三个正整数d<sub>j</sub>, s<sub>j</sub>, t<sub>j</sub>,表示租借的数量,租借开始、结束分别在第几天。 </p> <p class="MsoNormal" align="left"> 每行相邻的两个数之间均用一个空格隔开。天数与订单均用从1开始的整数编号。 </p>

<p class="MsoNormal" align="left"> 输出文件为 classroom.out </p> <p class="MsoNormal" align="left"> 如果所有订单均可满足,则输出只有一行,包含一个整数 0。否则(订单无法完全满足)输出两行,第一行输出一个负整数-1,第二行输出需要修改订单的申请人编号。 </p>

4 3 2 5 4 3 2 1 3 3 2 4 4 2 4

-1 2

0

<div class="WordSection1"> <p class="MsoNormal" align="left"> 【输入输出样例说明】 </p> </div> <p class="MsoNormal" align="left"> 1份订单满足后,4天剩余的教室数分别为 0323。第2份订单要求第2天到第4天每天提供3个教室,而第3 天剩余的教室数为2,因此无法满足。分配停止,通知第2个申请人修改订单。 </p> <p class="MsoNormal" align="left"> 【数据范围】 </p> <p class="MsoNormal" align="left"> 对于10%的数据,有1 ≤ n, m ≤ 10 </p> <p class="MsoNormal" align="left"> 对于30%的数据,有1 ≤ n, m ≤ 1000 </p> <p class="MsoNormal" align="left"> 对于70%的数据,有1 ≤ n, m ≤ 10<sup>5</sup> </p> <p class="MsoNormal" align="left"> 对于100%的数据,有1 ≤ n, m ≤ 10<sup>6</sup>, 0 ≤ r<sub>i</sub>, d<sub>j</sub>≤ 10<sup>9</sup>, 1 ≤ s<sub>j</sub>≤ t<sub>j</sub>≤ n </p>

NOIP2012DAY2(二)

2017-07-29 12:29:10

1

128

N

1

1

0

1889

疫情控制

<p class="MsoNormal" align="left"> H 国有 n 个城市,这 n 个城市用 n-1 条双向道路相互连通构成一棵树,1 号城市是首都,也是树中的根节点。 </p> <p class="MsoNormal" align="left"> H 国的首都爆发了一种危害性极高的传染病。当局为了控制疫情,不让疫情扩散到边境城市(叶子节点所表示的城市),决定动用军队在一些城市建立检查点,使得从首都到边境城市的每一条路径上都至少有一个检查点,边境城市也可以建立检查点。但特别要注意的是,首都是不能建立检查点的。 </p> <p class="MsoNormal" align="left"> 现在,在 H国的一些城市中已经驻扎有军队,且一个城市可以驻扎多个军队。一支军队可以在有道路连接的城市间移动,并在除首都以外的任意一个城市建立检查点,且只能在一个城市建立检查点。一支军队经过一条道路从一个城市移动到另一个城市所需要的时间等于道路的长度(单位:小时)。 </p> <p class="MsoNormal" align="left"> 请问最少需要多少个小时才能控制疫情。注意:不同的军队可以同时移动。 </p>

<p class="MsoNormal" align="left"> 输入文件名为 <span>blockade.in</span> </p> <p class="MsoNormal" align="left"> 第一行一个整数 <span>n</span>,表示城市个数。 </p> <p class="MsoNormal" align="left"> 接下来的 <span>n-1 </span>行,每行 <span>3 </span>个整数,uvw,每两个整数之间用一个空格隔开,表示从城市 <span>u </span>到城市 <span>v </span>有一条长为 <span>w </span>的道路。数据保证输入的是一棵树,且根节点编号为 <span>1</span>。接下来一行一个整数 <span>m</span>,表示军队个数。接下来一行 <span>m </span>个整数,每两个整数之间用一个空格隔开,分别表示这 <span>m </span>个军队所驻扎的城市的编号。 </p>

<p class="MsoNormal" align="left"> 输出文件为 blockade.out </p> <p class="MsoNormal" align="left"> 共一行,包含一个整数,表示控制疫情所需要的最少时间。如果无法控制疫情则输出-1 </p>

4 1 2 1 1 3 2 3 4 3 2 2 2

3

0

<div class="WordSection1"> <p class="MsoNormal" align="left"> 【输入输出样例说明】 </p> </div> <p class="MsoNormal" align="left"> 第一支军队在 2 号点设立检查点,第二支军队从 2 号点移动到 3 号点设立检查点,所需时间为 3 个小时。 </p> <p class="MsoNormal" align="left"> 【数据范围】 </p> <p class="MsoNormal" align="left"> 保证军队不会驻扎在首都。 </p> <p class="MsoNormal" align="left"> 对于 20%的数据,2≤ n≤ 10 </p> <p class="MsoNormal" align="left"> 对于 40%的数据,2 ≤n≤500<w <10<sup>5</sup> </p> <p class="MsoNormal" align="left"> 对于 60%的数据,2 ≤ n≤10000<w <10<sup>6</sup> </p> <p class="MsoNormal" align="left"> 对于 80%的数据,2 ≤ n≤10,000 </p> <p class="MsoNormal" align="left"> 对于 100%的数据,2≤m≤n≤50,0000<w <10<sup>9</sup> </p>

NOIP2012DAY2(三)

2017-07-29 12:36:37

2

128

N

0

0

0

1890

铺地毯

为了准备一个独特的颁奖典礼,组织者在会场的一片矩形区域(可看做是平面直角坐标系的第一象限)铺上一些矩形地毯。一共有n 张地毯,编号从1 n。现在将这些地毯按照编号从小到大的顺序平行于坐标轴先后铺设,后铺的地毯覆盖在前面已经铺好的地毯之上。地毯铺设完成后,组织者想知道覆盖地面某个点的最上面的那张地毯的编号。注意:在矩形地毯边界和四个顶点上的点也算被地毯覆盖。<br />

输入文件名为 carpet.in<br /> 输入共 n+2 行。<br /> 第一行,一个整数 n,表示总共有n 张地毯。<br /> 接下来的 n 行中,第i+1 行表示编号i 的地毯的信息,包含四个正整数abgk,每两个整数之间用一个空格隔开,分别表示铺设地毯的左下角的坐标(ab)以及地毯在x轴和y 轴方向的长度。<br />  n+2 行包含两个正整数x y,表示所求的地面的点的坐标(xy)。<br />

输出文件名为 carpet.out<br /> 输出共 1 行,一个整数,表示所求的地毯的编号;若此处没有被地毯覆盖则输出-1<br />

【输入输出样例 1 3 1 0 2 3 0 2 3 3 2 1 3 3 2 2 【输入输出样例 2 3 1 0 2 3 0 2 3 3 2 1 3 3 4 5

【输入输出样例 1 3 【输入输出样例 2 -1

0

【输入输出样例1说明】<br /> <p> 如下图,1 号地毯用实线表示,2 号地毯用虚线表示,3 号用双实线表示,覆盖点(22)的最上面一张地毯是3号地毯。 </p> <p> <img src="/JudgeOnline/upload/image/20170729/20170729125040_73942.png" alt="" width="400" height="364" title="" align="" /> </p> <p> 【输入输出样例2说明】<br /> 如上图,1 号地毯用实线表示,2 号地毯用虚线表示,3 号用双实线表示,点(45)没有被地毯覆盖,所以输出-1<br /> 【数据范围】<br /> 对于 30%的数据,有n≤2<br /> 对于 50%的数据,0≤a, b, g, k≤100<br /> 对于 100%的数据,有0≤n≤10,0000≤a, b, g, k≤100,000 </p>

NOIP2011DAY1(一)

2017-07-29 12:53:43

1

128

N

11

17

0

1891

选择客栈

丽江河边有 n 家很有特色的客栈,客栈按照其位置顺序从1 n 编号。每家客栈都按照某一种色调进行装饰(总共k 种,用整数0 ~ k-1 表示),且每家客栈都设有一家咖啡店,每家咖啡店均有各自的最低消费。<br /> <p> 两位游客一起去丽江旅游,他们喜欢相同的色调,又想尝试两个不同的客栈,因此决定分别住在色调相同的两家客栈中。晚上,他们打算选择一家咖啡店喝咖啡,要求咖啡店位于两人住的两家客栈之间(包括他们住的客栈),且咖啡店的最低消费不超过p </p> <p> 他们想知道总共有多少种选择住宿的方案,保证晚上可以找到一家最低消费不超过p元的咖啡店小聚。 </p>

输入文件 hotel.in,共n+1 行。<br /> 第一行三个整数 nkp,每两个整数之间用一个空格隔开,分别表示客栈的个数,色调的数目和能接受的最低消费的最高值;<br /> 接下来的n行,第i+1行两个整数,之间用一个空格隔开,分别表示i 号客栈的装饰色调和i号客栈的咖啡店的最低消费。<br />

<p> 输出文件名为 hotel.out </p> <p> 输出只有一行,一个整数,表示可选的住宿方案的总数。 </p>

5 2 3 0 5 1 3 0 2 1 4 1 5

3

0

<p> 【输入输出样例说明】 </p> <p> <img src="/JudgeOnline/upload/image/20170729/20170729125741_74603.png" alt="" width="600" height="115" title="" align="" /> </p> <p> 2人要住同样色调的客栈,所有可选的住宿方案包括:住客栈①③②④②⑤④⑤,但是若选择住45号客栈的话,45号客栈之间的咖啡店的最低消费是4,而两人能承受的最低消费是3元,所以不满足要求。因此只有前3种方案可选。 </p> <p> 【数据范围】<br /> 对于 30%的数据,有n≤100<br /> 对于 50%的数据,有n≤1,000<br /> 对于 100%的数据,有2≤n≤200,0000<k≤500≤p≤100 0≤最低消费≤100 </p>

NOIP2011DAY1(二)

2017-07-29 12:57:56

1

128

N

1

1

0

1892

Mayan游戏

Mayan puzzle 是最近流行起来的一个游戏。游戏界面是一个7 5 列的棋盘,上面堆放着一些方块,方块不能悬空堆放,即方块必须放在最下面一行,或者放在其他方块之上。游戏通关是指在规定的步数内消除所有的方块,消除方块的规则如下:<br /> <p> 1、每步移动可以且仅可以沿横向(即向左或向右)拖动某一方块一格:当拖动这一方块时,如果拖动后到达的位置(以下称目标位置)也有方块,那么这两个方块将交换位置(参见输入输出样例说明中的图6 到图7);如果目标位置上没有方块,那么被拖动的方块将从原来的竖列中抽出,并从目标位置上掉落(直到不悬空,参见下面图1 和图2); </p> <p> <img src="/JudgeOnline/upload/image/20170729/20170729125924_53100.png" alt="" width="600" height="302" title="" align="" /> </p> <p> 2、任一时刻,如果在一横行或者竖列上有连续三个或者三个以上相同颜色的方块,则它们将立即被消除(参见图1 到图3)。<br /> 注意:<br /> a) 如果同时有多组方块满足消除条件,几组方块会同时被消除(例如下面图4,三个颜色为1 的方块和三个颜色为2 的方块会同时被消除,最后剩下一个颜色为2 的方块)。<br /> b) 当出现行和列都满足消除条件且行列共享某个方块时,行和列上满足消除条件的所有方块会被同时消除(例如下面图5 所示的情形,5 个方块会同时被消除)。 </p> <p> <img src="/JudgeOnline/upload/image/20170729/20170729130004_13383.png" alt="" width="500" height="161" title="" align="" /> </p> <p> 3、方块消除之后,消除位置之上的方块将掉落,掉落后可能会引起新的方块消除。注意:掉落的过程中将不会有方块的消除。<br /> 上面图 1 到图3 给出了在棋盘上移动一块方块之后棋盘的变化。棋盘的左下角方块的坐标为(0, 0),将位于(3, 3)的方块向左移动之后,游戏界面从图1 变成图2 所示的状态,此时在一竖列上有连续三块颜色为4 的方块,满足消除条件,消除连续3 块颜色为4 的方块后,上方的颜色为3 的方块掉落,形成图3 所示的局面。 </p>

输入文件 mayan.in,共6 行。<br /> 第一行为一个正整数 n,表示要求游戏通关的步数。<br /> 接下来的 5 行,描述7*5 的游戏界面。每行若干个整数,每两个整数之间用一个空格隔开,每行以一个0 结束,自下向上表示每竖列方块的颜色编号(颜色不多于10 种,从1 开始顺序编号,相同数字表示相同颜色)。<br /> 输入数据保证初始棋盘中没有可以消除的方块。<br />

<p> 输出文件名为 mayan.out </p> <p> 如果有解决方案,输出n 行,每行包含3 个整数xyg,表示一次移动,每两个整数之间用一个空格隔开,其中(xy)表示要移动的方块的坐标,g 表示移动的方向,1 表示向右移动,-1 表示向左移动。注意:多组解时,按照x 为第一关健字,y 为第二关健字,1优先于-1,给出一组字典序最小的解。游戏界面左下角的坐标为(00)。<br /> 如果没有解决方案,输出一行,包含一个整数-1 </p>

3 1 0 2 1 0 2 3 4 0 3 1 0 2 4 3 4 0

2 1 1 3 1 1 3 0 1

0

【输入输出样例说明】<br /> <p> 按箭头方向的顺序分别为图6到图11 </p> <p> <img src="/JudgeOnline/upload/image/20170729/20170729130313_99301.png" alt="" width="500" height="421" title="" align="" /> </p> <p> 样例输入的游戏局面如上面第一个图片所示,依次移动的三步是:(21)处的方格向右移动,(31)处的方格向右移动,(30)处的方格向右移动,最后可以将棋盘上所有方块消除。<br /> 【数据范围】<br /> 对于 30%的数据,初始棋盘上的方块都在棋盘的最下面一行;<br /> 对于 100%的数据,0 < n≤5 </p>

NOIP2011DAY1(三)

2017-07-29 13:03:35

3

128

N

0

0

0

1893

计算系数

给定一个多项式(ax + by)<sup>k</sup>,请求出多项式展开后x<sup>n</sup> y<sup>m</sup>项的系数。

输入文件名为 factor.in<br /> 共一行,包含 5 个整数,分别为abknm,每两个整数之间用一个空格隔开。<br />

输出文件名为 factor.out<br /> 输出共 1 行,包含一个整数,表示所求的系数,这个系数可能很大,输出对10007取模后的结果。<br />

1 1 3 1 2

3

0

【数据范围】<br /> 对于 30%的数据,有0≤k≤10<br /> 对于 50%的数据,有a = 1b = 1<br /> 对于 100%的数据,有0≤k≤1,0000≤n, m≤k,且n + m = k0≤ab≤1,000,000<br />

NOIP2011DAY2(一)

2017-07-29 13:05:38

1

128

N

3

8

0

1894

聪明的质监员

 T 是一名质量监督员,最近负责检验一批矿产的质量。这批矿产共有n 个矿石,从1<br /> n 逐一编号,每个矿石都有自己的重量wi 以及价值vi。检验矿产的流程是:<br /> 1、给定m 个区间[LiRi]<br /> 2、选出一个参数W<br /> 3、对于一个区间[LiRi],计算矿石在这个区间上的检验值Yi <br /> <img src="/JudgeOnline/upload/image/20170729/20170729130720_74693.png" alt="" width="500" height="58" title="" align="" /><br /> 这批矿产的检验结果Y 为各个区间的检验值之和。即: <img src="/JudgeOnline/upload/image/20170729/20170729130735_49384.png" alt="" width="80" height="57" title="" align="" /><br /> 若这批矿产的检验结果与所给标准值S 相差太多,就需要再去检验另一批矿产。小T不想费时间去检验另一批矿产,所以他想通过调整参数W 的值,让检验结果尽可能的靠近标准值S,即使得S-Y 的绝对值最小。请你帮忙求出这个最小值。<br />

<p> 输入文件 qc.in </p> <p> 第一行包含三个整数 nmS,分别表示矿石的个数、区间的个数和标准值。<br /> 接下来的 n 行,每行2 个整数,中间用空格隔开,第i+1 行表示i 号矿石的重量wi 和价值vi <br /> 接下来的 m 行,表示区间,每行2 个整数,中间用空格隔开,第i+n+1 行表示区间[Li,Ri]的两个端点Li Ri<strong>注意:不同区间可能重合或相互重叠。</strong> </p>

输出文件名为 qc.out<br /> 输出只有一行,包含一个整数,表示所求的最小值。<br />

5 3 15 1 5 2 5 3 5 4 5 5 5 1 5 2 4 3 3

10

0

【输入输出样例说明】<br />  W 4 的时候,三个区间上检验值分别为2050,这批矿产的检验结果为25,此时与标准值S 相差最小为10<br /> 【数据范围】<br /> 对于 10%的数据,有1≤nm≤10<br /> 对于 30%的数据,有1≤nm≤500<br /> 对于 50%的数据,有1≤nm≤5,000<br /> 对于 70%的数据,有1≤nm≤10,000<br /> 对于 100%的数据,有1≤nm≤200,0000 < wi, vi≤1060 < S≤10121≤Li≤Ri≤n<br />

NOIP2011DAY2(二)

2017-07-29 13:08:56

1

128

N

1

1

0

1895

观光公交

<p> 风景迷人的小城 Y 市,拥有n 个美丽的景点。由于慕名而来的游客越来越多,Y 市特意安排了一辆观光公交车,为游客提供更便捷的交通服务。观光公交车在第0 分钟出现在1号景点,随后依次前往234……n 号景点。从第i 号景点开到第i+1 号景点需要Di 分钟。任意时刻,公交车只能往前开,或在景点处等待。 </p> <p> 设共有 m 个游客,每位游客需要乘车1 次从一个景点到达另一个景点,第i 位游客在Ti 分钟来到景点Ai,希望乘车前往景点BiAi<Bi)。为了使所有乘客都能顺利到达目的地,公交车在每站都必须等待需要从该景点出发的所有乘客都上车后才能出发开往下一景点。假设乘客上下车不需要时间。<br /> 一个乘客的旅行时间,等于他到达目的地的时刻减去他来到出发地的时刻。因为只有一辆观光车,有时候还要停下来等其他乘客,乘客们纷纷抱怨旅行时间太长了。于是聪明的司机ZZ 给公交车安装了k 个氮气加速器,每使用一个加速器,可以使其中一个Di 1。对于同一个Di 可以重复使用加速器,但是必须保证使用后Di 大于等于0 </p> <p> 那么 ZZ 该如何安排使用加速器,才能使所有乘客的旅行时间总和最小? </p>

输入文件名为 bus.in<br />  1 行是3 个整数n, m, k,每两个整数之间用一个空格隔开。分别表示景点数、乘客数和氮气加速器个数。<br />  2 行是n-1 个整数,每两个整数之间用一个空格隔开,第i 个数表示从第i 个景点开往第i+1 个景点所需要的时间,即Di<br />  3 行至m+2 行每行3 个整数Ti, Ai, Bi,每两个整数之间用一个空格隔开。第i+2 行表示第i 位乘客来到出发景点的时刻,出发的景点编号和到达的景点编号。<br />

输出文件名为 bus.out。共一行,包含一个整数,表示最小的总旅行时间。

3 3 2 1 4 0 1 3 1 1 2 5 2 3

10

0

【输入输出样例说明】<br />  D2 使用2 个加速器,从2 号景点到3 号景点时间变为2 分钟。<br /> 公交车在第 1 分钟从1 号景点出发,第2 分钟到达2 号景点,第5 分钟从2 号景点出发,第7 分钟到达3 号景点。<br />  1 个旅客旅行时间 7-0 = 7 分钟。<br />  2 个旅客旅行时间 2-1 = 1 分钟。<br />  3 个旅客旅行时间 7-5 = 2 分钟。<br /> 总时间 7+1+2 = 10 分钟。<br /> 【数据范围】<br /> 对于 10%的数据,k=0<br /> 对于 20%的数据,k=1<br /> 对于 40%的数据,2 ≤ n ≤ 501 ≤ m≤ 1,0000 ≤ k ≤ 200 ≤ Di ≤ 100 ≤ Ti ≤ 500<br /> 对于 60%的数据,1 ≤ n ≤ 1001 ≤ m≤ 1,0000 ≤ k ≤ 1000 ≤ Di ≤ 1000 ≤ Ti ≤ 10,000<br /> 对于 100%的数据,1 ≤ n ≤ 1,0001 ≤ m ≤ 10,0000 ≤ k ≤ 100,0000 ≤ Di ≤ 100<br /> 0 ≤ Ti ≤ 100,000<br />

NOIP2011DAY2(三)

2017-07-29 13:10:55

1

128

N

0

0

0

2118

【苏州NOId019: 计算1+2+3+4......+n 之和

计算1+2+3+4......+n 之和  (注意:这里的n是一个非常大的整数)

<span> 输入说明: 一个整数 n </span>

<span>输出说明: 和 </span>

输入样例: 100

输出样例 : 5050

0

 

 

2017-12-11 13:24:07

1

128

N

75

193

0